source: source/ariba/communication/modules/transport/protlib/network_message.h@ 5638

/// ----------------------------------------*- mode: C++; -*--
/// @file network_message.h
/// generic class for network messages (PDUs coming from/going to network)
/// ----------------------------------------------------------
/// $Id: network_message.h 3247 2008-07-28 20:54:54Z bless $
/// $HeadURL: https://svn.ipv6.tm.uka.de/nsis/protlib/trunk/include/network_message.h $
// ===========================================================
//                      
// Copyright (C) 2005-2007, all rights reserved by
// - Institute of Telematics, Universitaet Karlsruhe (TH)
//
// More information and contact:
// https://projekte.tm.uka.de/trac/NSIS
//                      
// 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; version 2 of the License
//
// 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 Street, Fifth Floor, Boston, MA 02110-1301 USA.
//
// ===========================================================

/** @ingroup networkmsg
 *
 * This is a generic class for network messages. 
 * A network message consists of a number of bytes.
 * There are no access member functions. So the user has full control over
 * the buffer.
 */
 
#ifndef _PROTLIB__NETWORK_MESSAGE_H_
#define _PROTLIB__NETWORK_MESSAGE_H_

#include <netinet/in.h>
#include <string>
#include <ostream>

#include "protlib_types.h"

namespace protlib {

/** @addtogroup networkmsg Network Messages
 * @ingroup network
 * @{
 */

class NetMsgError : public ProtLibException {
public:
        enum error_t {
                ERROR_TOO_LONG,
                ERROR_NO_MEM,
                ERROR_INVALID_POS,
                ERROR_NULL_POINTER,
                ERROR_INVALID_START_OFFSET,
                ERROR_TOO_SHORT,
                ERROR_INVALID_BUFSIZE
        };
        NetMsgError(error_t e);
        const char * getstr() const;
        virtual const char *what() const throw() { return getstr(); }
        const error_t err;
private:
        static const char* const errstr[];
}; // end NetMsgError

/// network message
/** This class is used to exchange data between signalling and transport
* protocol.
*/
class NetMsg {
public:
        static const uint32 max_size;
        /// constructor
        NetMsg(uint32 s);
        /// constructor
        NetMsg(uchar *b, uint32 s, bool copy = true);
        /// copy constructor
        NetMsg(const NetMsg& n);
        /// destructor
        ~NetMsg();
        /// get buffer size
        uint32 get_size() const;
        /// get bytes left until buffer ends
        uint32 get_bytes_left() const;
        /// get pointer offset
        uint32 get_pos() const;
        /// move pointer to offset
        NetMsg& set_pos(uint32 p);
        /// move pointer relative
        NetMsg& set_pos_r(int32 rp);
        /// set pointer to beginning
        NetMsg& to_start();
        /// copy into NetMsg buffer
        uint32 copy_from(const uchar *b, uint32 n);
        /// copy into NetMsg buffer
        uint32 copy_from(const uchar *b, uint32 start, uint32 end);
        /// copy from NetMsg buffer
        uint32 copy_to(uchar *b, uint32 n) const;
        /// copy from NetMsg buffer
        uint32 copy_to(uchar *b, uint32 start, uint32 n) const;
        /// get pointer to buffer
        uchar* get_buffer() const;
        /// decode uint8
        uint8 decode8(bool move = true);
        /// decode uint16
        uint16 decode16(bool move = true);
        /// decode uint32
        uint32 decode32(bool move = true);
        /// decode uint64
        uint64 decode64(bool move = true);
        /// decode uint128
        uint128 decode128(bool move = true);
        /// encode uint8
        void encode8(uint8 i, bool move = true);
        /// encode uint16
        void encode16(uint16 i, bool move = true);
        /// encode uint32
        void encode32(uint32 i, bool move = true);
        /// encode uint64
        void encode64(uint64 i, bool move = true);
        /// encode uint128
        void encode128(uint128 i, bool move = true);
        /// decode uchars
        void decode(uchar *c, uint32 len, bool move = true);
        /// encode uchars
        void encode(const uchar *c, uint32 len, bool move = true);
        /// decode string
        uint32 decode(string& s, uint32 len, bool move = true);
        /// encode string
        uint32 encode(const string& s, bool move = true);
        /// decode IPv4
        void decode(struct in_addr& in, bool move = true);
        /// encode IPv4
        void encode(const struct in_addr& in, bool move = true);
        /// decode IPv6
        void decode(struct in6_addr& in, bool move = true);
        /// encode IPv6
        void encode(const struct in6_addr& in, bool move = true);
        /// truncate buffer
        uint32 truncate();
        /// truncate buffer
        uint32 truncate(uint32 t);
        /// apply padding
        void padding(uint32 len, bool move = true);
        /// test for equality
        bool operator==(const NetMsg& n) const;
        /// encode a NetMsg into this NetMsg
        void encode(const NetMsg& m, uint32 len, bool move = true);
        /// decode a NetMsg from this NetMsg
        void decode(NetMsg& m, bool move = true);
        /// print a raw hexdump of the buffer
        ostream& hexdump(ostream& os, uchar *startpos=0, uint32 length=0) const;

private:
        /// buffer for data
        uchar *buf;
        /// buffer size
        uint32 buf_len;     
        /// current reading/writing position
        uchar *pos;
        /// buffer end
        /** Ponter to the last byte of the buffer. */   
        uchar *buf_end;
};

inline std::ostream &operator<<(std::ostream &out, const NetMsg &msg) {
        msg.hexdump(out);
        return out;
}

//@}

} // namespace protlib

#endif // _PROTLIB__NETWORK_MESSAGE_H_