Tcp.h

Go to the documentation of this file.

#ifndef CASTOR_NET_CHANNELS_TCP_H
#define CASTOR_NET_CHANNELS_TCP_H 1

#include <set>

#include <boost/enable_shared_from_this.hpp>
#include <boost/thread/mutex.hpp>
#include <boost/bind.hpp>

#include <asio.hpp>

#include <CastorChannel.h>

namespace castor { namespace net { namespace channels {

        class Tcp : public CastorChannel {

                private:

                        class Connection {

                                protected:

                                        friend class Tcp;

                                        NetAddress address;

                                        asio::ip::tcp::socket socket;
                
                                        Tcp *channel;

                                        bool closed;

                                        char buffer[8192];

                                        void handleRead(const asio::error_code& error, size_t count);

                                        Connection(const Connection &other);
                                        Connection &operator=(const Connection &other);

                                public:

                                        Connection(asio::io_service &service, Tcp *tcp);

                                        virtual ~Connection();
                                        
                                        inline asio::ip::tcp::socket &getSocket();

                                        void start(const NetAddress &address);
                                        void stop();
                        };

                        typedef boost::shared_ptr<Connection> ConnectionPtr;
                        typedef std::map<NetAddress, ConnectionPtr> ConnectionMap;
                        
                        ConnectionMap connections;

                        asio::io_service *service;

                        asio::ip::tcp::acceptor acceptor;
                        asio::ip::tcp::socket socket;

                        asio::ip::tcp::endpoint endpoint;
                        asio::ip::tcp::endpoint remoteEndpoint;

                        boost::mutex mutex;

                        bool opened;

                protected:

                        Tcp(asio::io_service &service);

                        void add(ConnectionPtr connection);
                        void remove(const NetAddress &address);

                        void handleAccept(ConnectionPtr connection, const asio::error_code& error);
                        void handleConnect(const asio::error_code& error);
                        void handleSend(const asio::error_code& error, size_t count);
                        void handleRead(const asio::error_code& error, size_t count);

                public:

                        Tcp(asio::io_service &service, const NetAddress &a);

                        virtual ~Tcp();

                        virtual NetAddress getLocalAddress();

                        virtual void setAsync(bool async);

                        virtual void open();
                        virtual void open(const NetAddress &a);
                        virtual void bind();

                        virtual void reuseAddress(bool on);
                        virtual bool reuseAddress();

                        virtual void enableLoopback(bool on);
                        virtual bool enableLoopback();

                        virtual void enableBroadcast(bool on);
                        virtual bool enableBroadcast();

                        virtual void multicastHops(int hops);
                        virtual int multicastHops();

                        virtual void joinGroup(const asio::ip::address &address);
                        virtual void leaveGroup(const asio::ip::address &address);

                        virtual void accept() throw(NetException);
                        virtual void connect() throw(NetException);

            virtual void close() throw(NetException);
            virtual void close(const NetAddress &address) throw(NetException);
            virtual bool isOpen();

            virtual size_t receive(char *data, size_t length);
            virtual size_t receive(char *data, size_t length, NetAddress &remote);

            virtual void send(const char *data, size_t length);
            virtual void send(const char *data, size_t length, const NetAddress &remote);

        };

} } }

#endif /* CASTOR_NET_CHANNELS_TCP_H */