xdrbuf.cpp

Go to the documentation of this file.

/*
 * xdrbuf.cpp
 *
 * Copyright (c) 2008,2009 Thomas A. Vaughan
 * All rights reserved.
 *
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * 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.
 *     * Neither the name of the <organization> nor the
 *       names of its contributors may be used to endorse or promote products
 *       derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THOMAS A. VAUGHAN ''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 THOMAS A. VAUGHAN 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.
 *
 * XDR input/output buffers.  See xdrbuf.h
 */

// includes --------------------------------------------------------------------
#include "xdrbuf.h"             // always include our own header first

#include <string.h>

#ifdef WIN32
#include "winsock.h"
#else   // WIN32
#include "netinet/in.h"         // for htonl, htons, ntohl, etc
#endif  // WIN32

#include "common/wave_ex.h"


namespace xdrbuf {

/// \ingroup xdrbuf
/*@{*/


// interface destructors
Output::~Output(void) throw() { }
Input::~Input(void) throw() { }


static const char s_nameLookup[] = "\0abcdefghijklmnopqrstuvwxyz$*?!=";


////////////////////////////////////////////////////////////////////////////////
//
//      static helper methods
//
////////////////////////////////////////////////////////////////////////////////

static int
getNameIndex
(
IN char a
)
{
        if (a >= 'a' && a <= 'z')
                return a - 'a' + 1;
        if (a == '$')
                return 27;
        if (a == '*')
                return 28;
        if (a == '?')
                return 29;
        if (a == '!')
                return 30;
        if (a == '=')
                return 31;

        ASSERT(false, "Invalid name: '%c' = %d", a, a);
        return 0;
}



class RealPackletHeader : public PackletHeader {
public:
        RealPackletHeader(IN word_t& w) { this->setData(w); }
};



static word_t
createPackletHeaderData
(
IN char name,
IN ePackletType type,
IN int size
)
{
        if (!isValidPackletName(name)) {
                WAVE_EX(wex);
                wex << "Invalid packlet name: " << name;
        }
        if (type < 1 || type > 5) {
                WAVE_EX(wex);
                wex << "Invalid packlet type: " << type;
        }
        if (size < 0 || size > 255) {
                WAVE_EX(wex);
                wex << "Invalid packlet data size: " << size;
        }

        word_t p;       // this is the packlet data

        // first, add the type
        p = type;
        p = p << 5;     // make room for name (5 bits)

        // next, add the name
        int i = getNameIndex(name);
        p += (word_t) i;
        p = p << 8;     // make room for size (8 bits)

        // now add the element count
        p += (word_t) size;

        //DPRINTF("Created packlet:");
        //DPRINTF("  name: '%c'", name);
        //DPRINTF("  type: %d", type);
        //DPRINTF("  size: %d", size);
        //DPRINTF("  result: 0x%02x", p);

        //getPackletName(p);
        //getPackletType(p);
        //getPackletDataCount(p);

        return p;
}


////////////////////////////////////////////////////////////////////////////////
//
//      OutBuf -- class that implements the Output interface
//
////////////////////////////////////////////////////////////////////////////////

class OutBuf : public Output {
public:
        OutBuf(void) throw();
        ~OutBuf(void) throw();

        // public class methods ------------------------------------------------
        void initialize(IN int size);

        // Output class interface methods -----------------------------
        void clear(void);
        int getRemainingBytes(void) const throw();
        void openPacklet(IN char name);
        void closePacklet(IN char name);
        void addStringPacklet(IN char name,
                                IN const char * s,
                                IN int length);
        void addFloatPacklet(IN char name,
                                IN const float * data,
                                IN int nFloats);
        void addInt32Packlet(IN char name,
                                IN const int32_t * data,
                                IN int nInt32s);
        const byte_t * getData(void) throw();
        int getDataBytes(void) const throw() { return m_pos; }

private:
        typedef std::vector<byte_t> vec_data_t;
        typedef std::vector<char> vec_char_t;

        // private helper methods ----------------------------------------------
        void addPacklet(IN word_t p);

        // private member data -------------------------------------------------
        int                                     m_pos;  // current position
        vec_data_t                              m_data;
        vec_char_t                              m_packletStack;
        int                                     m_size;
};



OutBuf::OutBuf(void)
throw()
{
        m_size = 0;
        m_pos = -1;
}



OutBuf::~OutBuf(void)
throw()
{
}



void
OutBuf::initialize
(
IN int bytes
)
{
        ASSERT(bytes > 0, "Bad byte size: %d", bytes);

        ASSERT(!m_size, "Already initialized?");
        m_size = bytes;

        m_data.resize(bytes);
        m_pos = 0;
}



void
OutBuf::clear
(
void
)
{
        ASSERT(m_size > 0, "Bad size: %d", m_size);

        m_pos = 0;
        ASSERT(m_size == this->getRemainingBytes(),
            "Should have %d bytes remaining!", m_size);
        m_packletStack.clear();
}



int
OutBuf::getRemainingBytes
(
void
)
const
throw()
{
        ASSERT(m_pos >= 0, "Bad position: %d", m_pos);
        return m_size - m_pos;
}



void
OutBuf::openPacklet
(
IN char name
)
{
        word_t p = createPackletHeaderData(name, ePacklet_ParentBegin, 0);
        this->addPacklet(p);
        m_packletStack.push_back(name);
}



void
OutBuf::closePacklet
(
IN char name
)
{
        if (!isValidPackletName(name)) {
                WAVE_EX(wex);
                wex << "Invalid packlet name: " << name;
        }

        // see what is at the top (end) of the packlet stack
        if (m_packletStack.size() == 0) {
                WAVE_EX(wex);
                wex << "Cannot close packlet: nothing open!  ";
                wex << "Attempting to close packlet '" << name << "'";
        }

        vec_char_t::iterator i = m_packletStack.end();
        --i;
        char b = *i;
        if (b != name) {
                WAVE_EX(wex);
                wex << "Closing a packlet that isn't open?  ";
                wex << "Packlet '" << b << "' was opened, but packlet '";
                wex << name << "' was closed.";
        }

        // okay, matches!
        m_packletStack.pop_back();
//      DPRINTF("  stack size: %d", m_packletStack.size());
        word_t p = createPackletHeaderData(name, ePacklet_ParentEnd, 0);
        this->addPacklet(p);
}



void
OutBuf::addStringPacklet
(
IN char name,
IN const char * s,
IN int length
)
{
        word_t p = createPackletHeaderData(name, ePacklet_String, length);
        this->addPacklet(p);

        // verify space remaining
        ASSERT_THROW(this->getRemainingBytes() >= length,
            "Out of room in outbut buffer--cannot add string packlet");

        strncpy((char *) (&m_data[0] + m_pos), s, length);
        m_pos += length;
}



void
OutBuf::addFloatPacklet
(
IN char name,
IN const float * data,
IN int nFloats
)
{
        word_t p = createPackletHeaderData(name, ePacklet_Floats, nFloats);
        this->addPacklet(p);

        // verify space remaining
        int bytes_needed = nFloats * sizeof(float);
        ASSERT_THROW(sizeof(dword_t) == sizeof(float),
            "Our encoding assumes long and float are same size!");
        ASSERT_THROW(this->getRemainingBytes() >= bytes_needed,
            "out of room in output buffer--cannot add float packlet");

        for (int i = 0; i < nFloats; ++i) {

                // This is the only place I miss XDR!
                // I have to convert local floats into something that
                //   can be read over the network, and then converted
                //   back on another host with a different architecture.
                // You can see the IEEE floating point standard here:
                //   http://en.wikipedia.org/wiki/Floating_point
                // However, I'm not going to do a custom encoding of
                //   sign, mantissa, exponent.  Instead, we just
                //   follow proper endian-ness and hope other OS's
                //   use the same standard.  This can be updated over
                //   time to be more robust.
                dword_t in;
                memcpy(&in, data + i, sizeof(dword_t));
                dword_t out = htonl(in);        // convert to network byte order

                memcpy(&m_data[0] + m_pos, &out, sizeof(dword_t));
                m_pos += sizeof(dword_t);
        }
}



void
OutBuf::addInt32Packlet
(
IN char name,
IN const int32_t * data,
IN int nInt32s
)
{
        word_t p = createPackletHeaderData(name, ePacklet_Int32s, nInt32s);
        this->addPacklet(p);

        // verify remaining size
        int bytes_needed = nInt32s * sizeof(int32_t);
        ASSERT_THROW(this->getRemainingBytes() >= bytes_needed,
            "out of room in output buffer--cannot add long packlet");

        for (int i = 0; i < nInt32s; ++i) {
                dword_t out = htonl(data[i]);
                memcpy(&m_data[0] + m_pos, &out, sizeof(dword_t));
                m_pos += sizeof(dword_t);
        }
}



const byte_t *
OutBuf::getData
(
void
)
throw()
{
        if (m_packletStack.size()) {
                WAVE_EX(wex);
                wex << "Unclosed packlets?  Stack is not empty";
        }

        return &m_data[0];
}



void
OutBuf::addPacklet
(
IN word_t p
)
{
        // verify there is room!
        ASSERT_THROW(this->getRemainingBytes() >= 2,
            "Out of room in output buffer--cannot add packlet");

        // convert to network byte order
        word_t w = htons(p);
        byte_t * b = (byte_t *) &w;

        m_data[m_pos++] = b[0];
        m_data[m_pos++] = b[1];
}



////////////////////////////////////////////////////////////////////////////////
//
//      InBuf -- class that implements the xdrbuf::Input interface
//
////////////////////////////////////////////////////////////////////////////////

class InBuf : public Input {
public:
        InBuf(void) throw();
        ~InBuf(void) throw();

        // public class methods ------------------------------------------------
        void initialize(void) { }

        // xdrbuf::Input class interface methods -------------------------------
        void reset(IN const byte_t * stream,
                                IN int bytes);
        bool endOfStream(void);
        PackletHeader getNextPackletHeader(void);
        void readInt32s(OUT int32_t * buffer, IN int count);
        void readFloats(OUT float * buffer, IN int count);
        void readString(OUT char * buffer, IN int count);

private:
        // private helper methods ----------------------------------------------
        enum eExpect {
                eExpect_Packlet         = 1,
                eExpect_Data            = 2,
                eExpect_Invalid         = 0
        };

        int getRemainingBytes(void) const throw() { return m_bytes - m_pos; }

        // private member data -------------------------------------------------
        const byte_t *          m_stream;
        eExpect                 m_expect;
        ePackletType            m_type;
        int                     m_pos;          // current position in input
        int                     m_count;
        int                     m_bytes;
};



InBuf::InBuf
(
void
)
throw()
{
        m_expect = eExpect_Invalid;
        m_bytes = 0;
        m_count = -1;
        m_type = ePacklet_Invalid;
        m_stream = NULL;
        m_pos = -1;
}



InBuf::~InBuf
(
void
)
throw()
{
}



void
InBuf::reset
(
IN const byte_t * stream,
IN int bytes
)
{
        ASSERT(stream, "null");
        ASSERT(bytes > 0, "bad byte count: %d", bytes);

        m_stream = stream;
        m_bytes = bytes;
        m_expect = eExpect_Packlet;
        m_type = ePacklet_Invalid;
        m_count = -1;
        m_pos = 0;
}



bool
InBuf::endOfStream
(
void
)
{
        if (!m_stream)
                return true;

        return (m_pos >= m_bytes);
}



PackletHeader
InBuf::getNextPackletHeader
(
void
)
{
        if (eExpect_Packlet != m_expect) {
                WAVE_EX(wex);
                wex << "Packlet header is not expected";
        }
        ASSERT_THROW(this->getRemainingBytes() >= 2,
            "Not enough data remaining for another packlet header");

        // convert back from network to host byte order
        word_t * pw = (word_t *) (m_stream + m_pos);
        word_t w = ntohs(*pw);
        m_pos += 2;

        // now cast
        PackletHeader * pph = (PackletHeader *) &w;
        PackletHeader ph = *pph;

        m_type = ph.getType();
        if (ePacklet_Invalid == m_type) {
                WAVE_EX(wex);
                wex << "Invalid packet type";
        }

        m_count = ph.getDataCount();
        if (ePacklet_ParentBegin == m_type ||
            ePacklet_ParentEnd == m_type) {
                m_expect = eExpect_Packlet;
        } else {
                m_expect = eExpect_Data;
        }

        return ph;
}



void
InBuf::readInt32s
(
OUT int32_t * buffer,
IN int count
)
{
        ASSERT(buffer, "null");
        ASSERT(count >= 0, "Bad count");

        if (eExpect_Data != m_expect || ePacklet_Int32s != m_type) {
                WAVE_EX(wex);
                wex << "No int32s available for reading!";
        }
        m_type = ePacklet_Invalid;
        m_expect = eExpect_Packlet;

        if (count != m_count) {
                WAVE_EX(wex);
                wex << "Mismatch in packlet/read counts";
        }

        // verify we have the data
        int bytes_needed = count * sizeof(int32_t);
        ASSERT_THROW(this->getRemainingBytes() >= bytes_needed,
            "Not enough remaining data for " << count << " longs");

        for (int i = 0; i < count; ++i) {
                dword_t in = *(dword_t *)(m_stream + m_pos);
                m_pos += sizeof(dword_t);
                buffer[i] = ntohl(in);
        }
}



void
InBuf::readFloats
(
OUT float * buffer,
IN int count
)
{
        ASSERT(buffer, "null");
        ASSERT(count >= 0, "Bad count");

        if (eExpect_Data != m_expect || ePacklet_Floats != m_type) {
                WAVE_EX(wex);
                wex << "No floats available for reading!";
        }
        m_type = ePacklet_Invalid;
        m_expect = eExpect_Packlet;

        if (count != m_count) {
                WAVE_EX(wex);
                wex << "Mismatch in packlet/read counts";
        }

        // verify there is data to read
        int bytes_needed = count * sizeof(float);
        ASSERT_THROW(this->getRemainingBytes() >= bytes_needed,
            "Not enough remaining data for " << count << " floats");
        ASSERT_THROW(sizeof(float) == sizeof(dword_t),
            "Our decoding assumes floats and longs are the same size");

        for (int i = 0; i < count; ++i) {
                // see OutBuf::addFloatPacklet about caveats
                dword_t in;
                memcpy(&in, m_stream + m_pos, sizeof(dword_t));
                m_pos += sizeof(dword_t);
                dword_t out = ntohl(in);
                memcpy(buffer + i, &out, sizeof(dword_t));
        }
}



void
InBuf::readString
(
OUT char * buffer,
IN int count
)
{
        ASSERT(buffer, "null");
        ASSERT(count >= 0, "Bad count");

        if (eExpect_Data != m_expect || ePacklet_String != m_type) {
                WAVE_EX(wex);
                wex << "No string availabile for reading!";
        }
        m_type = ePacklet_Invalid;
        m_expect = eExpect_Packlet;

        if (count != m_count) {
                WAVE_EX(wex);
                wex << "Mismatch in packlet/read counts";
        }

        // verify we have enough data
        ASSERT_THROW(this->getRemainingBytes() >= count,
            "Not enough remaining data to read string of size " << count);

        // copy the characters to the provided buffer
        strncpy(buffer, (const char *) (m_stream + m_pos), count);
        m_pos += count;
}



////////////////////////////////////////////////////////////////////////////////
//
//      Public APIs
//
////////////////////////////////////////////////////////////////////////////////

bool
isValidPackletName
(
IN char a
)
{
        if (a >= 'a' && a <= 'z')
                return true;
        if (a == ')' || a == '(')
                return true;
        if (a == '?' || a == '!')
                return true;
        if (a == '=')
                return true;

        return false;
}



char
PackletHeader::getName
(
void
)
const
throw()
{
        byte_t b = (byte_t) ((m_data & 0xFF00) >> 8);   // get high byte
        int i = b & 0x1F;                               // lowest 5 bits

        //DPRINTF("Packlet 0x%02x --> name 0x%02x", p, i);

        if (i <= 0) {
                DPRINTF("Null or invalid packet name?  %d", i);
                return 0;
        }

        if (i > 31) {
                DPRINTF("Index too large? %d", i);
                return 0;
        }
        return s_nameLookup[i];
}



ePackletType
PackletHeader::getType
(
void
)
const
throw()
{
        byte_t b = (byte_t) ((m_data & 0xFF00) >> 8);   // high byte
        int i = b & 0xE0;                               // highest 3 bits
        i = i >> 5;

        //DPRINTF("Packlet 0x%02x --> type 0x%02x", p, i);

        if (i <= 0) {
                DPRINTF("Null or invalid packlet type? %d", i);
                return ePacklet_Invalid;
        }
        if (i >= 6) {
                DPRINTF("Invalid packlet type? %d", i);
                return ePacklet_Invalid;
        }
        return (ePackletType) i;
}



int
PackletHeader::getDataCount
(
void
)
const
throw()
{
        byte_t b = (byte_t) (m_data & 0x00FF);          // low byte

        //DPRINTF("Packlet 0x%02x --> count %d == 0x%02x", p, (int) b, b);

        return (int) b;
}



smart_ptr<Output>
Output::create
(
IN int bytes
)
{
        ASSERT(bytes > 0, "Bad byte count: %d", bytes);

        smart_ptr<OutBuf> local = new OutBuf;
        ASSERT(local, "out of memory");

        local->initialize(bytes);

        return local;
}



smart_ptr<Input>
Input::create
(
void
)
{
        smart_ptr<InBuf> local = new InBuf;
        ASSERT(local, "out of memory");

        local->initialize();

        return local;
}



};      // xdrbuf namespace