srv-hosts.cpp

Go to the documentation of this file.

/*
 * srv-hosts.cpp
 *
 * Copyright (C) 2009  Thomas A. Vaughan
 * All rights reserved.
 *
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in the
 *       documentation and/or other materials provided with the distribution.
 *     * Neither the name of the <organization> nor the
 *       names of its contributors may be used to endorse or promote products
 *       derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THOMAS A. VAUGHAN ''AS IS'' AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL THOMAS A. VAUGHAN BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * Host management.  See srv-hosts.h
 */

// includes -------------------------------------------------------------------
#include "srv-hosts.h"          // always include our own header first!

#include "common/wave_ex.h"

#include "threadsafe/threadsafe_map.h"


namespace aesop {


HostManager::~HostManager(void) throw() { }



//
//      HostMgr -- object that implements the HostManager interface
//

class HostMgr : public HostManager {
public:
        HostMgr(void) throw();
        ~HostMgr(void) throw() { }

        // public class methods ------------------------------------------------
        void initialize(IN int udpSize);

        // aesop::HostManager class interface methods --------------------------
        void addHost(IN conn_id_t hostId,
                                IN long udpToken,
                                IN const char * publicKey);
        bool getHostByUdpConnectionID(IN conn_id_t udpConnID,
                                OUT host_rec_t& hr);
        bool getHostByTcpConnectionID(IN conn_id_t tcpConnID,
                                OUT host_rec_t& hr);
        void updateHost(IN host_rec_t& hr);
        bool removeHost(IN conn_id_t hostId);
        void getIterator(OUT iterator_t& iterator);
        bool getNextHost(IO iterator_t& iterator,
                                OUT host_rec_t& pr);

private:
        // private typedefs ----------------------------------------------------
        struct host_data_t {
                host_rec_t      hr;
        };

        typedef threadsafe_map<conn_id_t, smart_ptr<host_data_t> > host_map_t;

        // private helper methods ----------------------------------------------
        static host_map_t::iterator_t * castIterator(IN iterator_t& i) throw() {
                        return (host_map_t::iterator_t *) &i;
                }

        // private member data -------------------------------------------------
        host_map_t                      m_hosts;
        int                             m_udpSize;
};



HostMgr::HostMgr(void)
throw()
{
        m_udpSize = 0;
}



void
HostMgr::initialize
(
IN int udpSize
)
{
        ASSERT(udpSize > 63 && udpSize <= 1024, "Bad udp size: %d", udpSize);

        m_udpSize = udpSize;

        // verify public iterator size
        ASSERT2(sizeof(iterator_t) >= sizeof(host_map_t::iterator_t),
            "Public iterator is too small!  " << sizeof(iterator_t) 
            << " bytes vs. " << sizeof(host_map_t::iterator_t) << " bytes.");
}



//
//      HostMgr -- aesop::HostManager class interface methods
//

void
HostMgr::addHost
(
IN conn_id_t hostId,
IN long udpToken,
IN const char * publicKey
)
{
        ASSERT(hostId, "null");
        ASSERT(udpToken, "null");
        ASSERT(publicKey, "null");

        // quick check--already have a host here?
        // This can fail due to race conditions!  But this should catch
        //      obvious errors.
        smart_ptr<host_data_t> hd;
        if (m_hosts.lookup(hostId, hd)) {
                DPRINTF("Already have a host record for conn_id=%lu",
                    (long) hostId);
                return;
        }

        // set up new host data
        hd = new host_data_t;
        ASSERT(hd, "out of memory");
        host_rec_t& hr = hd->hr;        // convenient reference

        hr.mode = eHostMode_Connected;
        hr.udpConn = hostId;
        hr.udpToken = udpToken;
        hr.netQueue = netrq::Queue::create();
        hr.desKey = crypto::DESKey::create();
        hr.outbuf = xdrbuf::Output::create(m_udpSize);
        hr.publicKey = crypto::RSAPublicKey::create(publicKey);

        // all good!
        m_hosts.insert(hostId, hd);
}



bool
HostMgr::getHostByUdpConnectionID
(
IN conn_id_t hostId,
OUT host_rec_t& hr
)
{
        ASSERT(hostId, "null");

        hr.clear();

        smart_ptr<host_data_t> hd;
        if (!m_hosts.lookup(hostId, hd))
                return false;           // not found!

        // copy over fields
        hr = hd->hr;

        // done
        return true;
}



bool
HostMgr::getHostByTcpConnectionID
(
IN conn_id_t tcpConnID,
OUT host_rec_t& hr
)
{
        hr.clear();
        // For efficiency, we could keep a 2nd map.
        // However, these lookups are infrequent (occasional TCP message).
        // So we just iterate every time we are asked.

        host_map_t::iterator_t i;
        m_hosts.getIterator(i);

        conn_id_t hostId;
        smart_ptr<host_data_t> hd;
        while (m_hosts.getNextElement(i, hostId, hd)) {
                if (tcpConnID == hd->hr.tcpConn) {
                        // matched!
                        hr = hd->hr;
                        return true;
                }
        }

        // failed to find tcp connection id!
        return false;
}



void
HostMgr::updateHost
(
IN host_rec_t& hr
)
{
        ASSERT(hr.udpConn, "null");

        smart_ptr<host_data_t> hd;
        if (!m_hosts.lookup(hr.udpConn, hd)) {
                DPRINTF("Attempting to update a non-existent host?");
                return;
        }
        ASSERT(hd, "null host data in map");

        // copy over for now
        // TODO: is this safe?  Could have multiple threads reading as this is
        //      updating.
        //  This is believed to be safe, since all components (primitive types
        //      or smart_ptrs) are threadsafe. 
        hd->hr = hr;
}



bool
HostMgr::removeHost
(
IN conn_id_t hostId
)
{
        ASSERT(hostId, "null");

        return m_hosts.remove(hostId);
}



void
HostMgr::getIterator
(
OUT iterator_t& iterator
)
{
        host_map_t::iterator_t * ri = castIterator(iterator);
        ASSERT(ri, "null");

        m_hosts.getIterator(*ri);
}



bool
HostMgr::getNextHost
(
IO iterator_t& iterator,
OUT host_rec_t& hr
)
{
        hr.clear();

        host_map_t::iterator_t * ri = castIterator(iterator);
        ASSERT(ri, "null");

        conn_id_t hostId;
        smart_ptr<host_data_t> hd;
        if (!m_hosts.getNextElement(*ri, hostId, hd))
                return false;

        hr = hd->hr;
        return true;
}



//
//      HostMgr -- private helper methods
//



//
//      public API
//

smart_ptr<HostManager>
HostManager::create
(
IN int udpSize
)
{
        ASSERT(udpSize > 0, "bad udp size: %d", udpSize);

        smart_ptr<HostMgr> local = new HostMgr;
        ASSERT(local, "out of memory");

        local->initialize(udpSize);

        return local;
}



};      // aesop namespace