network_string.hpp

Go to the documentation of this file.

//
//  SuperTuxKart - a fun racing game with go-kart
//  Copyright (C) 2013-2015 SuperTuxKart-Team
//
//  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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 
#ifndef NETWORK_STRING_HPP
#define NETWORK_STRING_HPP
 
#include "network/protocol.hpp"
#include "utils/leak_check.hpp"
#include "utils/types.hpp"
#include "utils/vec3.hpp"
 
#include "LinearMath/btQuaternion.h"
 
#include "irrString.h"
 
#include <assert.h>
#include <stdarg.h>
#include <stdexcept>
#include <string>
#include <string.h>
#include <vector>
 
typedef unsigned char uchar;
 
class BareNetworkString
{
friend class Crypto;
private:
    LEAK_CHECK();
 
protected:
    std::vector<uint8_t> m_buffer;
 
    mutable int m_current_offset;
 
    // ------------------------------------------------------------------------
    std::string getString(int len) const
    {
        if (m_current_offset > (int)m_buffer.size() ||
            m_current_offset + len > (int)m_buffer.size())
            throw std::out_of_range("getString out of range.");
 
        std::string a(m_buffer.begin() + (m_current_offset      ),
                      m_buffer.begin() + (m_current_offset + len));
        m_current_offset += len;
        return a;
    }   // getString
    // ------------------------------------------------------------------------
    BareNetworkString& addString(const std::string& value)
    {
        for (unsigned int i = 0; i < value.size(); i++)
            m_buffer.push_back((uint8_t)(value[i]));
        return *this;
    }   // addString
 
    // ------------------------------------------------------------------------
    template<typename T, size_t n>
    T get() const
    {
        int a = n;
        T result = 0;
        m_current_offset += n;
        int offset = m_current_offset -1;
        while (a--)
        {
            result <<= 8; // offset one byte
                          // add the data to result
            result += m_buffer.at(offset - a);
        }
        return result;
    }   // get(int pos)
    // ------------------------------------------------------------------------
    template<typename T>
    T get() const
    {
        return m_buffer.at(m_current_offset++);
    }   // get
 
public:
 
    BareNetworkString(int capacity=16)
    {
        m_buffer.reserve(capacity);
        m_current_offset = 0;
    }   // BareNetworkString
 
    // ------------------------------------------------------------------------
    BareNetworkString(const std::string &s)
    {
        m_current_offset = 0;
        encodeString(s);
    }   // BareNetworkString
    // ------------------------------------------------------------------------
    BareNetworkString(const char *data, int len)
    {
        m_current_offset = 0;
        m_buffer.resize(len);
        memcpy(m_buffer.data(), data, len);
    }   // BareNetworkString
 
    // ------------------------------------------------------------------------
    void reset() { m_current_offset = 0; }
    // ------------------------------------------------------------------------
    BareNetworkString& encodeString16(const irr::core::stringw& value,
                                      uint16_t max_len = 65535);
    // ------------------------------------------------------------------------
    int decodeString16(irr::core::stringw* out,
                       uint16_t max_len = 65535);
    // ------------------------------------------------------------------------
    BareNetworkString& encodeString(const std::string &value);
    BareNetworkString& encodeString(const irr::core::stringw &value);
    int decodeString(std::string *out) const;
    int decodeStringW(irr::core::stringw *out) const;
    std::string getLogMessage(const std::string &indent="") const;
    // ------------------------------------------------------------------------
    std::vector<uint8_t>& getBuffer() { return m_buffer; }
 
    // ------------------------------------------------------------------------
    char* getData() { return (char*)(m_buffer.data()); };
 
    // ------------------------------------------------------------------------
    const char* getData() const { return (char*)(m_buffer.data()); };
 
    // ------------------------------------------------------------------------
    char* getCurrentData()
    {
        return (char*)(m_buffer.data()+m_current_offset);
    }   // getCurrentData
 
    // ------------------------------------------------------------------------
    const char* getCurrentData() const
    {
        return (char*)(m_buffer.data()+m_current_offset); 
    }   // getCurrentData
    // ------------------------------------------------------------------------
    int getCurrentOffset() const                   { return m_current_offset; }
    // ------------------------------------------------------------------------
    unsigned int size() const { return (int)m_buffer.size()-m_current_offset; }
 
    // ------------------------------------------------------------------------
    void skip(int n)
    {
        m_current_offset += n;
        assert(m_current_offset >=0 &&
               m_current_offset <= (int)m_buffer.size());
    }   // skip
    // ------------------------------------------------------------------------
    unsigned int getTotalSize() const { return (unsigned int)m_buffer.size(); }
    // ------------------------------------------------------------------------
    // All functions related to adding data to a network string
    BareNetworkString& addUInt8(const uint8_t value)
    {
        m_buffer.push_back(value);
        return *this;
    }   // addUInt8
 
    // ------------------------------------------------------------------------
    BareNetworkString& addChar(const char value)
    {
        m_buffer.push_back((uint8_t)(value));
        return *this;
    }   // addChar
    // ------------------------------------------------------------------------
    BareNetworkString& addUInt16(const uint16_t value)
    {
        m_buffer.push_back((value >> 8) & 0xff);
        m_buffer.push_back(value & 0xff);
        return *this;
    }   // addUInt16
 
    // ------------------------------------------------------------------------
    BareNetworkString& addInt24(const int value)
    {
        uint32_t combined = (uint32_t)value & 0xffffff;
        m_buffer.push_back((combined >> 16) & 0xff);
        m_buffer.push_back((combined >> 8) & 0xff);
        m_buffer.push_back(combined & 0xff);
        return *this;
    }   // addInt24
 
    // ------------------------------------------------------------------------
    BareNetworkString& addUInt32(const uint32_t& value)
    {
        m_buffer.push_back((value >> 24) & 0xff);
        m_buffer.push_back((value >> 16) & 0xff);
        m_buffer.push_back((value >>  8) & 0xff);
        m_buffer.push_back( value        & 0xff);
        return *this;
    }   // addUInt32
 
    // ------------------------------------------------------------------------
    BareNetworkString& addUInt64(const uint64_t& value)
    {
        m_buffer.push_back((value >> 56) & 0xff);
        m_buffer.push_back((value >> 48) & 0xff);
        m_buffer.push_back((value >> 40) & 0xff);
        m_buffer.push_back((value >> 32) & 0xff);
        m_buffer.push_back((value >> 24) & 0xff);
        m_buffer.push_back((value >> 16) & 0xff);
        m_buffer.push_back((value >>  8) & 0xff);
        m_buffer.push_back( value        & 0xff);
        return *this;
    }   // addUInt64
 
    // ------------------------------------------------------------------------
    BareNetworkString& addFloat(const float value)
    {
        uint32_t *p = (uint32_t*)&value;
        return addUInt32(*p);
    }   // addFloat
 
    // ------------------------------------------------------------------------
    BareNetworkString& operator+=(BareNetworkString const& value)
    {
        m_buffer.insert(m_buffer.end(),
                       value.m_buffer.begin()+value.m_current_offset,
                       value.m_buffer.end()   );
        return *this;
    }   // operator+=
 
    // ------------------------------------------------------------------------
    BareNetworkString& add(float f)
    {
        return addFloat(f);
    }   // add
    // ------------------------------------------------------------------------
    BareNetworkString& add(const Vec3 &xyz)
    {
        return addFloat(xyz.getX()).addFloat(xyz.getY()).addFloat(xyz.getZ());
    }   // add
 
    // ------------------------------------------------------------------------
    BareNetworkString& add(const btQuaternion &quat)
    {
        return addFloat(quat.getX()).addFloat(quat.getY())
              .addFloat(quat.getZ()).addFloat(quat.getW());
    }   // add
    // ------------------------------------------------------------------------
    BareNetworkString& addTime(int ticks)
    {
        return addUInt32(ticks);
    }   // addTime
 
    // Functions related to getting data from a network string
    // ------------------------------------------------------------------------
    inline uint64_t getUInt64() const { return get<uint64_t, 8>(); }
    // ------------------------------------------------------------------------
    inline uint32_t getUInt32() const { return get<uint32_t, 4>(); }
    // ------------------------------------------------------------------------
    inline int getInt24() const
    {
        uint32_t combined = get<uint32_t, 3>();
        if (combined & 0x800000)
            return (0x1000000 - (int)combined) * -1;
        else
            return (int)combined;
    }
    // ------------------------------------------------------------------------
    inline uint32_t getTime() const { return get<uint32_t, 4>(); }
    // ------------------------------------------------------------------------
    inline uint16_t getUInt16() const { return get<uint16_t, 2>(); }
    // ------------------------------------------------------------------------
    inline int16_t getInt16() const { return get<int16_t, 2>(); }
    // ------------------------------------------------------------------------
    inline uint8_t getUInt8() const
    {
        return m_buffer.at(m_current_offset++);
    }   // getUInt8
    // ------------------------------------------------------------------------
    inline int8_t getInt8() const
    {
        return m_buffer.at(m_current_offset++);
    }   // getInt8
    // ------------------------------------------------------------------------
    float getFloat() const
    {
        uint32_t u = getUInt32();
        float f;
        // Doig a "return *(float*)&u;" appears to be more efficient,
        // but it can create incorrect code on higher optimisation: c++
        // makes the assumption that pointer of different types never
        // overlap. So the compiler can assume that the int pointer (&u)
        // and float pointer do point to different aras, so there read
        // (*(float*) can be done before the write to u (and then the
        // write to u is basically a no-op and can be removed, too).
        // Using a union of int and float is not valid either, there
        // is no guarantee that writing to the int part of the union
        // will affect the float part. So, an explicit memcpy is the
        // more or less only portable guaranteed to be correct way of
        // converting the int to a float.
        memcpy(&f, &u, sizeof(float));
        return f;
    }   // getFloat
 
    // ------------------------------------------------------------------------
    Vec3 getVec3() const
    {
        Vec3 r;
        r.setX(getFloat());
        r.setY(getFloat());
        r.setZ(getFloat());
        return r;
    }   // getVec3
 
    // ------------------------------------------------------------------------
    btQuaternion getQuat() const
    {
        btQuaternion q;
        q.setX(getFloat());
        q.setY(getFloat());
        q.setZ(getFloat());
        q.setW(getFloat());
        return q;
    }   // getQuat
    // ------------------------------------------------------------------------
 
};   // class BareNetworkString
 
 
// ============================================================================
 
class NetworkString : public BareNetworkString
{
public:
    static void unitTesting();
        
    NetworkString(ProtocolType type,  int capacity=16)
        : BareNetworkString(capacity+1)
    {
        m_buffer.push_back(type);
    }   // NetworkString
 
    // ------------------------------------------------------------------------
    NetworkString(const uint8_t *data, int len) 
        : BareNetworkString((char*)data, len)
    {
        m_current_offset = 1;   // ignore type
    }   // NetworkString
 
    // ------------------------------------------------------------------------
    void clear()
    {
        m_buffer.erase(m_buffer.begin() + 1, m_buffer.end());
        m_current_offset = 1;
    }   // clear
    // ------------------------------------------------------------------------
    ProtocolType getProtocolType() const
    {
        return (ProtocolType)(m_buffer.at(0) & ~PROTOCOL_SYNCHRONOUS);
    }   // getProtocolType
 
    // ------------------------------------------------------------------------
    void setSynchronous(bool b)
    {
        if(b)
            m_buffer[0] |= PROTOCOL_SYNCHRONOUS;
        else
            m_buffer[0] &= ~PROTOCOL_SYNCHRONOUS;
    }   // setSynchronous
    // ------------------------------------------------------------------------
    bool isSynchronous() const
    {
        return (m_buffer[0] & PROTOCOL_SYNCHRONOUS) == PROTOCOL_SYNCHRONOUS;
    }   // isSynchronous
 
};   // class NetworkString
 
 
#endif // NETWORK_STRING_HPP