CastorChannel.cpp

Go to the documentation of this file.

#include "CastorChannel.h"
#include "Tcp.h"
#include "Udp.h"
#include "Exception.h"

namespace castor { namespace net {

        CastorChannel::CastorChannel(asio::io_service &service) :
                address(), buffer(), service(&service), strand(service),
                thread(), mode(mode_undefined), cb(), interfaces(),
                localAddresses(), closed(false), async(true), callback(), callbackExt(),
                peerAdded(), peerRemoved(), connectionLost(), connectionEstablished()
        {
                getIfaddrs();
        }

        CastorChannel::CastorChannel(const CastorChannel &other) :
                boost::enable_shared_from_this<CastorChannel>(),
                address(other.address), buffer(), service(other.service),
                strand(*other.service), thread(), mode(other.mode), cb(other.cb),
                interfaces(other.interfaces), localAddresses(other.localAddresses),
                closed(other.closed), async(true), callback(other.callback),
                callbackExt(other.callbackExt), peerAdded(other.peerAdded),
                peerRemoved(other.peerRemoved), connectionLost(other.connectionLost),
                connectionEstablished(other.connectionEstablished)
        {
        }

        CastorChannel::~CastorChannel() {
        }

        void CastorChannel::getIfaddrs() {

                NetInterfacePtrList list = NetInterface::getInterfaces();

                this->interfaces.clear();
                this->localAddresses.clear();

                for (size_t i = 0; i < list.size(); i++) {
                        NetInterfacePtr iface = list[i];
                        this->interfaces[iface->getName()] = iface;

                        NetAddressPtrSet addresses = iface->getAddresses();

                        for (NetAddressPtrSet::iterator itr = addresses.begin();
                                 itr != addresses.end(); itr++)
                        {
                                this->localAddresses.insert((*itr)->getAddress());
                        }
                }

/*              for (InterfaceMap::iterator itr = this->interfaces.begin();
                         itr != this->interfaces.end(); itr++)
                {
                        std::cout << itr->second->str() << std::endl;
                }*/
        }

        void CastorChannel::registerCallback(CCallbackPtr cb) {
                this->cb = cb;
        }

/*      void CastorChannel::signalReceive(const char *buffer, size_t count, NetAddressPtr address) {

                if (this->callback) {
                        this->callback(buffer, count, address);
                }
                if (this->callbackExt) {
                        this->callbackExt(buffer, count, address, shared_from_this());
                }
//              if (this->cb) {
//                      this->cb->call(buffer, count, address);
//              }
        }
*/
        CastorChannelPtr CastorChannel::create(asio::io_service &service, const std::string spec) throw(NetException) {

                NetAddressPtr address = NetAddress::create(spec);

                return CastorChannel::create(service, *address.get());
        }

        CastorChannelPtr CastorChannel::create(asio::io_service &service, const NetAddress &address) throw(NetException) {

                switch (address.getProtocol()) {

                        case IPPROTO_IP:
                        case IPPROTO_TCP:
                                return CastorChannelPtr(new castor::net::channels::Tcp(service, address));

                        case IPPROTO_UDP:
                                return CastorChannelPtr(new castor::net::channels::Udp(service, address));
 
                }

                throw NetException("Channel: unable to create new sender for %s!", address.str().c_str());
        }

        asio::mutable_buffers_1 CastorChannel::getBuffer() {
//              std::cout << "Cleaning buffer " << sizeof(this->buffer) << std::endl;
//              memset(this->buffer, 0, sizeof(this->buffer));
                return asio::buffer(this->buffer, sizeof(this->buffer));
        }

        asio::io_service &CastorChannel::getIoService() {
                return *service;
        }

        void CastorChannel::start() {
                this->thread = ThreadType(new asio::thread(boost::bind(&CastorChannel::run, this)));

//              this->thread->join();
        }

        void CastorChannel::run() {
                try {
                        this->service->run();

                } catch (std::exception &e) {
                        std::cerr << e.what() << std::endl;
                } catch (...) {
                        std::cerr << "Channel: uncaught exception" << std::endl;
                }
        }

        void CastorChannel::join() {

                this->service->stop();

                if (this->thread) {
                        this->thread->join();
                        this->service->reset();
                }
        }

        NetAddress &CastorChannel::getAddress() {
                return this->address;
        }

} }