Udp.h

Go to the documentation of this file.

#ifndef CASTOR_NET_CHANNELS_UDP_H
#define CASTOR_NET_CHANNELS_UDP_H 1

#include <set>

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

#include <asio.hpp>

#include <CastorChannel.h>

namespace castor { namespace net { namespace channels {

        class Udp : public CastorChannel {

                private:

                        asio::ip::udp::socket socket;

                        asio::ip::udp::endpoint endpoint;
                        asio::ip::udp::endpoint remoteEndpoint;
                        
                        boost::condition cond;
                        boost::mutex monitor;

                        NetAddressPtr localMcastAddress;

                        bool localMcastAddressHack;

                protected:

                        Udp(asio::io_service &service);

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

                public:

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

                        virtual ~Udp();

                        virtual void setAsync(bool async);

                        virtual NetAddress getLocalAddress();

                        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();

                        inline size_t receive(char *data, size_t length) {
                                return this->socket.receive(asio::buffer(data, length));
                        }

                        inline size_t receive(char *data, size_t length, NetAddress &remote) {

                                asio::ip::udp::endpoint ep;

                                size_t count = this->socket.receive_from(asio::buffer(data, length), ep);

                                remote = *NetAddress::create(this->address.getSpicaSpecific(), ep);

                                return count;
                        }

                        inline void send(const char *data, size_t length) {

                                if ((this->mode == mode_connect) || (this->address.isMulticast())) {

                                        try {
                                                this->socket.send_to(asio::buffer(data, length), this->endpoint);
                                        } catch (...) {
                                                // Silently drop exception
                                        }

                                } else {
                                        std::cerr << "Udp: unable to send data without remote endpoint in bind mode" << std::endl;
                                }
                        }

                        inline void send(const char *data, size_t length, const NetAddress &remote) {
                                asio::ip::udp::endpoint ep(remote.getAddress(), remote.getPort());

                                try {
                                        this->socket.send_to(asio::buffer(data, length), ep);
                                } catch (const std::exception &e) {
                                        // Silently drop exception
                                }

                        }
        };

} } }

#endif /* CASTOR_NET_CHANNELS_UDP_H */