aesop-client.cpp

Go to the documentation of this file.

/*
 * aesop-client.cpp
 *
 * Copyright (C) 2008-2010  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.
 *
 * See aesop-client.h
 */

// includes --------------------------------------------------------------------
#include "aesop-client.h"               // always include our own header first!

#include "object-sync.h"

// REMINDER: no rendering or input dependencies allowed!
#include "common/wave_ex.h"
#include "conversation/conversation.h"
#include "aesop-map/map.h"
#include "aesop-proto/message.h"
#include "aesop-proto/protocol.h"       // network protocol
#include "crypto/crypto.h"
#include "datahash/datahash_text.h"
#include "datahash/datahash_util.h"
#include "dialog/request.h"
#include "map-manager/map-manager.h"
#include "netrq/netrq.h"                // network request queue
#include "perf/perf.h"
#include "story/story.h"
#include "typeinst/typeinst.h"
#include "xdrbuf/xdrbuf.h"


namespace aesop {



typedef netlib::conn_id_t conn_id_t;
typedef netlib::envelope_t envelope_t;
typedef netlib::MessageBuffer MessageBuffer;

static const int s_maxIdLength                  = 32;

// countdowns to keep network traffic sane
static const int s_bigNumber                    = 32000;
static const int s_smallNumber                  = 2;

static int s_authCountdown                      = 0;

static const float s_maxTimeDelta               = 0.1;  // max dt
static const float s_minTimeDelta               = 1.0e-4; // 0.05ms

// outgoing UDP message buffer size (public key is ~400 bytes!)
static const int s_udpOutSize                   = 824;


// interface class destructors
ClientHost::~ClientHost(void) throw() { }
Client::~Client(void) throw() { }


// every player has one of these...
struct client_player_record_t {
        // constructor, manipulators
        client_player_record_t(void) throw() { this->clear(); }
        void clear(void) throw() {
                        objectId = 0;
                        delta.clear();
                        euler.clear();
                }

        // data fields
        dword_t         objectId;          // object this player is bound to
        point3d_t       delta;             // request to move by this delta
        point3d_t       euler;             // euler rotation (orientation)
};



static const float s_minStateMessageWaitTime            = 0.5;
static const float s_maxStateMessageWaitTime            = 3.0;


typedef std::map<int, smart_ptr<client_player_record_t> > player_map_t;


// loaded maps
typedef std::map<std::string, smart_ptr<Map> > id_map_t;


// conversation notes
struct converse_rec_t {
        // constructor, manipulators
        converse_rec_t(void) throw() { this->clear(); }
        void clear(void) throw() {
                        dialogId = 0;
                        playerId = 0;
                        connId = 0;
                }

        // data fields
        int                     dialogId;
        int                     playerId;
        conn_id_t               connId;
};

typedef std::map<std::string, smart_ptr<converse_rec_t> > conversation_map_t;


//
//      static helper methods
//

static const char *
getServerHashKey
(
IN const server_info_t& si,
IO char * buffer                // needs to be at least 32 bytes!!
)
{
        ASSERT2(si.isValid(), "invalid");
        ASSERT(buffer, "null");

        const byte_t * pb = si.address.ip.addr;
        sprintf(buffer, "%d.%d.%d.%d:%d",
            pb[0], pb[1], pb[2], pb[3], si.address.port);

        return buffer;
}



//
//      Request objects -- these know how to construct requests to the server
//       (actually, they inject request packlets into the larger UDP packet)
//

static const char * s_reqIdConnect      =       "connect";
static const char * s_reqIdAuthorize    =       "auth";


class QueryObjectRequest: public netrq::Request {
public:
        ~QueryObjectRequest(void) throw() { }

        // netrq::Request class interface methods ------------------------------
        void write(IN xdrbuf::Output * output) {
                        ASSERT(output, "null");
        //              DPRINTF("Asking about object %ld", m_objectId);
                        output->addInt32Packlet('q',
                            (int32_t *) &m_objectId, 1);
                }

        const char * getId(void) const throw() { return m_reqId; }

        int getMaxBytes(void) const throw() {
                        return 4 + 2;   // int32 plus header
                }

        // yes, keep resending
        int getRetryInterval(void) const throw() { return 24; }

        // static factory methods ----------------------------------------------
        static smart_ptr<netrq::Request> create(IN long objectId) {
                        ASSERT(objectId, "null");

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

                        sprintf(local->m_reqId, "qo%ld", objectId);
                        local->m_objectId = objectId;

                        return local;
                }

private:
        // private helper methods ----------------------------------------------
        QueryObjectRequest(void) throw() { }

        // private data members ------------------------------------------------
        dword_t         m_objectId;
        char            m_reqId[64];
};



class ConnectContext : public netrq::Request {
public:
        ~ConnectContext(void) throw() { }

        void write(IN xdrbuf::Output * output) {
                        ASSERT(output, "null");
                        output->openPacklet('c');
                        int32_t l[3];
                        l[0] = eProtocol_Long;
                        l[1] = m_token;
                        l[2] = m_port;
                        output->addInt32Packlet('v', l, 3);
                        output->openPacklet('p');
                        const char * key = m_key.c_str();
                        int len = m_key.length();
                        while (len) {
                                int send = len;
                                if (send > 255) {
                                        send = 255;
                                }
                                //DPRINTF("Sending %d bytes", send);
                                output->addStringPacklet('a', key, send);
                                key += send;
                                len -= send;
                        }
                        output->closePacklet('p');
                        output->closePacklet('c');
                }

        int getMaxBytes(void) const throw() {
                        return 384;
                }

        const char * getId(void) const throw()
                        { return s_reqIdConnect; }

        static smart_ptr<netrq::Request> create(IN long token,
                                IN int port,
                                IN const char * publicKey) {
                        ASSERT(token, "null");
                        ASSERT(port, "null");
                        ASSERT(publicKey, "null");

                        smart_ptr<ConnectContext> cc = new ConnectContext;
                        ASSERT(cc, "out of memory");

                        cc->m_token = token;
                        cc->m_port = port;
                        cc->m_key = publicKey;

                        return cc;
                }

private:
        ConnectContext(void) { }

        long            m_token;
        int             m_port;         // local UDP port server should use
        std::string     m_key;          // public key
};



class AuthorizeContext : public netrq::Request {
public:
        AuthorizeContext(IN const char * password) {
                        ASSERT(password, "null");
                        m_password = password;
                }
        ~AuthorizeContext(void) throw() { }

        void write(IN xdrbuf::Output * output) {
                        ASSERT(output, "null");

                        output->addStringPacklet('a',
                            m_password.c_str(),
                            m_password.length());
                }

        int getMaxBytes(void) const throw() {
                        return 259 + 2;
                }

        const char * getId(void) const throw()
                { return s_reqIdAuthorize; }
private:
        std::string     m_password;     // encrypted
};



//
//      ClientImpl - class that implements the Client interface
//

class ClientImpl : public Client,
                        public dialog::Host,
                        public converse::ConversationRouter {
public:
        ClientImpl(void) throw();
        ~ClientImpl(void) throw() { }

        // public class methods ------------------------------------------------
        void initialize(IN ClientHost * host,
                                IN smart_ptr<story::Story>& story,
                                IN smart_ptr<Datahash>& params);

        // aesop::Client class interface methods -------------------------------
        story::Story * getStory(void) throw() { return m_story; }
        eClientState getState(void) throw() { return m_clientState; }
        bool getServer(OUT server_info_t& si);
        const server_map_t& getDiscoveredServers(void) { return m_servers; }
        bool requestConnect(IN const char * serverKey);
        float tick(void);
        bool createPlayer(IN int playerId);
        void startLocalConversation(IN const char * guid,
                                IN int playerId,
                                IN smart_ptr<converse::ConversationHost> host);
        bool isConversationUnderway(IN const char * guid);
        void newGame(IN int playerId);
        void requestMove(IN int playerId,
                                IN const point3d_t& delta,
                                IN const point3d_t& euler,
                                OUT point3d_t& newPosition);
        bool getPlacement(IN int playerId,
                                OUT placement_t& placement);
        smart_ptr<PhysicsObject>  getPlayerObject(IN int playerId);

        // dialog::Host class interface methods --------------------------------
        void notifySubmit(IN const char * id,
                                IN const Datahash * data);

        // converse::ConversationRouter class interface methods ----------------
        void routeConversationTS(IN const char * guid,
                                IN int dialogId,
                                IN int playerId,
                                IN conn_id_t connId,
                                IN const char * dialogData);

private:
        // private helper methods ----------------------------------------------
        client_player_record_t * getPlayer(IN int playerId);
        converse_rec_t * getConversation(IN const char * conversationGuid);
        void deleteConversation(IN const char * guid,
                                IN int playerId);
        void checkHostState(void);
        void handleMessage(IN const envelope_t& envelope,
                                IN const MessageBuffer * msg);
        void handleUDP(IN const envelope_t& envelope,
                                IN const MessageBuffer * msg);
        void handleBroadcast(IN xdrbuf::PackletHeader ph,
                                IN const envelope_t& env);
        void readConnectUDP(IO xdrbuf::Input * input);
        void readDestroyUDP(IO xdrbuf::Input * input);
        void readPlayerUDP(IO xdrbuf::Input * input);
        void readQueryUDP(IN const xdrbuf::PackletHeader& ph,
                                IO xdrbuf::Input * input);
        void readObjectUDP(IO xdrbuf::Input * input);
        void setKeys(IN const char * encryptedDesKey);
        void sendUdpPacket(IN float dt);

        // private data members ------------------------------------------------
        ClientHost *                            m_host; // weak reference!
        server_map_t                            m_servers; // discovered servers
        server_info_t                           m_server; // target server
        eClientState                            m_clientState;
        conn_id_t                               m_tcpConnID;
        conn_id_t                               m_localUdpConnID;
        conn_id_t                               m_remoteUdpConnID;
        player_map_t                            m_players;
        conversation_map_t                      m_conversations;
        smart_ptr<converse::ConversationManager> m_conversationMgr;
        eHostMode                               m_hMode;
        smart_ptr<crypto::RSAKey>               m_rsaKey;       // pub/priv key
        smart_ptr<crypto::DESKey>               m_desKey;       // symmetric
        bool                                    m_haveProtocol;
        int                                     m_localUdpPort;
        int                                     m_remoteUdpPort;
        int                                     m_serverTcpPort;
        dword_t                                 m_udpMostRecentClock; //server
        dword_t                                 m_udpClock;     // our udp clock
        dword_t                                 m_lastUdpServerSaw;
        long                                    m_udpConnToken;
        id_map_t                                m_maps;
        smart_ptr<xdrbuf::Input>                m_udpIn;
        smart_ptr<xdrbuf::Output>               m_udpOut;
        smart_ptr<ObjectSync>                   m_syncMgr;
        smart_ptr<MapManager>                   m_mapMgr;
        smart_ptr<story::Story>                 m_story;
        smart_ptr<netrq::Queue>                 m_netQueue;
        perf::time_t                            m_lastTime;
        float                                   m_lastdt;     // last time delta
        float                                   m_lastUdpSent;
};



ClientImpl::ClientImpl(void) throw()
{
        m_host = NULL;  // weak reference -- do not delete!
        m_server.clear();       // not connected yet
        m_clientState = eClientState_Invalid;
        m_tcpConnID = 0;
        m_localUdpConnID = 0;
        m_remoteUdpConnID = 0;
        m_haveProtocol = false;
        m_localUdpPort = 0;
        m_remoteUdpPort = 0;
        m_serverTcpPort = 0;
        m_hMode = eHostMode_Invalid;
        m_udpMostRecentClock = 0;
        m_udpClock = 0;
        m_lastUdpServerSaw = 0;
        m_udpConnToken = 0;
        m_lastdt = 0.0;
        m_lastUdpSent = 0.0;
}



void
ClientImpl::initialize
(
IN ClientHost * host,
IN smart_ptr<story::Story>& story,
IN smart_ptr<Datahash>& params
)
{
        ASSERT(host, "null");
        ASSERT(story, "null");
        ASSERT(params, "null");

        // save host
        ASSERT(!m_host, "already have a host?");
        m_host = host;

        // save story object
        ASSERT(!m_story, "already have a story?");
        m_story = story;

        // set up our outgoing UDP buffer
        ASSERT(s_udpOutSize > 31 && s_udpOutSize < 1025,
            "Bad udp output buffer size: %d", s_udpOutSize);
        ASSERT(!m_udpOut, "Already have a udp output buffer?");
        m_udpOut = xdrbuf::Output::create(s_udpOutSize);
        ASSERT(m_udpOut, "failed to create xdr output buffer");

        // set up incoming UDP buffer
        ASSERT(!m_udpIn, "Already have a udp input buffer?");
        m_udpIn = xdrbuf::Input::create();
        ASSERT(m_udpIn, "Failed to create xdr input parser");

        // get local UDP port
        m_localUdpPort = eDefaultPort_clientUdp;
        DPRINTF("Default client UDP port: %d", m_localUdpPort);
        const char * udpOverride =
            getString(params, "udpPort", eDatahash_Optional);
        if (udpOverride) {
                DPRINTF("Overriding client UDP port: %s", udpOverride);
                m_localUdpPort = atoi(udpOverride);
        }
        if (m_localUdpPort <= 0) {
                WAVE_EX(wex);
                wex << "Bad local UDP port: " << m_localUdpPort;
        }

        // construct RSA key (public/private keys)
        m_rsaKey = crypto::RSAKey::create();
        ASSERT(m_rsaKey, "failed to create RSA key");

        // construct a network request queue
        ASSERT(!m_netQueue, "already have a network request queue?");
        m_netQueue = netrq::Queue::create();
        ASSERT(m_netQueue, "failed to create network request queue");

        // create a local UDP connection for sending and receiving
        netlib::address_t udpAddress;
        udpAddress.setlocal(m_localUdpPort);
        udpAddress.dump("udp address");
        m_localUdpConnID = netlib::createUdpLocal(udpAddress);
        ASSERT(m_localUdpConnID, "failed to create local udp port?");

        // create map manager
        ASSERT(!m_mapMgr, "already have a map manager?");
        m_mapMgr = MapManager::create(params, m_story);
        ASSERT(m_mapMgr, "null");

        // create synchronization manager
        ASSERT(!m_syncMgr, "already have an object synchronization manager?");
        m_syncMgr = ObjectSync::create(m_mapMgr);
        ASSERT(m_syncMgr, "null");

        // create local conversation manager
        ASSERT(!m_conversationMgr, "Already have a conversation manager?");
        m_conversationMgr = converse::ConversationManager::create(this);
        ASSERT(m_conversationMgr, "null");

        // initialize type instance library
        initializeTypeInstanceLibrary(m_story);

        // okay, all set
        m_clientState = eClientState_Searching;
}



//
//      ClientImpl -- aesop::Client class interface methods
//

bool
ClientImpl::getServer
(
OUT server_info_t& si
)
{
        si = m_server;
        return si.isValid();
}



bool
ClientImpl::requestConnect
(
IN const char * serverKey
)
{
        ASSERT(serverKey, "null");

        // already connected?
        if (m_server.isValid()) {
                DPRINTF("Ignoring request to connect: we are connected!");
                return false;
        }

        DPRINTF("Player wants this server: %s", serverKey);
        m_server.clear();
        bool found = m_servers.lookup(serverKey, m_server);
        if (!found) {
                DPRINTF("No such server: %s", serverKey);
                return false;
        }

        // okay, set up udp connection
        ASSERT_THROW(!m_remoteUdpConnID,
            "Not connected but have a remote UDP connection?");
        m_remoteUdpConnID =
            netlib::createUdpRemote(m_localUdpConnID, m_server.address);
        ASSERT(m_remoteUdpConnID, "failed to create remote udp connection");

        // all good
        return true;
}



float
ClientImpl::tick
(
void
)
{
        // need to send anything to server?
        this->checkHostState();

        // tick all conversations
        m_conversationMgr->updateAll();

        // receive any messages from server
        // (and call getNextMessage() which is core message pump)
        envelope_t env;
        smart_ptr<MessageBuffer> msg;
        long microseconds = 500;                // 500us == 0.5ms
        try {
                usleep(10 * microseconds);
                if (netlib::getNextMessage(microseconds, env, msg)) {
                        this->handleMessage(env, msg);
                }
        } catch (std::exception& e) {
                netlib::dumpMessage(std::cerr, "Error handling this message",
                    env, msg);
                DPRINTF("Exception: %s", e.what());
        }

        // get elapsed time
        perf::time_t now = perf::getNow();
        perf::time_t delta = now;
        delta.decrement(m_lastTime);
        m_lastTime = now;
        float dt = (float) delta.getSeconds();
        if (dt > s_maxTimeDelta) {
                dt = s_maxTimeDelta;
        } else if (dt <= s_minTimeDelta) {
                // set to very small but positive amount
                dt = s_minTimeDelta;
        }
        m_lastdt = dt;  // remember this...

        // tick maps!
        m_mapMgr->tickMaps(dt);

        // send UDP packet 
        // NOTE: this assumes tick() isn't being called too frequently!
        m_lastUdpSent += dt;
        const float s_sendHz = 50.0;    // TODO: config-driven send rate!
        const float s_sendRate = 1.0 / s_sendHz;
        if (m_lastUdpSent > s_sendRate) {
                this->sendUdpPacket(m_lastUdpSent);
                m_lastUdpSent = 0.0;
        }

        // update local object state
        if (m_udpClock)
                m_syncMgr->clientUpdate(m_udpClock);

        // return elapsed time to callers
        return dt;
}



bool
ClientImpl::createPlayer
(
IN int playerId
)
{
        ASSERT(playerId > 0, "Bad player id: %d", playerId);

        // already exists?
        if (this->getPlayer(playerId)) {
                // already exists!
                return false;
        }

        // okay, create
        DPRINTF("New client player");
        smart_ptr<client_player_record_t> player = new client_player_record_t;
        ASSERT(player, "out of memory");

        m_players[playerId] = player;
        ASSERT(2 == player.get_ref_count(), "Bad count");

        // all done
        return true;
}



void
ClientImpl::startLocalConversation
(
IN const char * guid,
IN int playerId,
IN smart_ptr<converse::ConversationHost> host
)
{
        ASSERT(guid, "null");
        ASSERT(playerId > 0, "Bad player id: %d", playerId);
        ASSERT(host, "null");
        ASSERT(m_conversationMgr, "null");

        // already have this?
        if (this->getConversation(guid)) {
                return;         // conversation is already underway
        }

        // create conversation record
        smart_ptr<converse_rec_t> cr = new converse_rec_t;
        ASSERT(cr, "out of memory");

        cr->playerId = playerId;
        cr->connId = 0;         // local conversation
        cr->dialogId = host->getCurrentDialogIdTS();
        m_conversations[guid] = cr;

        // create conversation with null connection ID to denote local
        m_conversationMgr->updateConversationTS(guid, 0, playerId, host);
}



bool
ClientImpl::isConversationUnderway
(
IN const char * guid
)
{
        ASSERT(guid, "null");

        // already have this?
        if (this->getConversation(guid))
                return true;
        return false;
}



void
ClientImpl::newGame
(
IN int playerId
)
{
        ASSERT(playerId > 0, "Bad player id: %d", playerId);

        DPRINTF("Requesting new game!");

        smart_ptr<netlib::MessageBuffer> msg = createNewGameMessage(playerId);
        ASSERT(msg, "null");

        netlib::enqueueMessage(m_tcpConnID, msg);
}



void
ClientImpl::requestMove
(
IN int playerId,
IN const point3d_t& delta,
IN const point3d_t& euler,
OUT point3d_t& newPosition
)
{
        ASSERT(playerId > 0, "Bad player id: %d", playerId);

        client_player_record_t * prec = this->getPlayer(playerId);
        if (!prec) {
                // this shouldn't happen!
                DPRINTF("Unrecognized player id: %d", playerId);
                return;
        }
        if (!prec->objectId) {
                // happens a lot!  when joining, between maps, etc
                // DPRINTF("Player is not yet bound to an object");
                return;
        }

        // let state manager know
        if (!m_syncMgr->clientMoveRequest(prec->objectId, delta, m_lastdt,
            newPosition)) {
                DPRINTF("Object ID not found? %lu", (long) prec->objectId);
        }

        // update record with player's wish
        prec->delta += delta;   // accumulate requested moves
        prec->euler = euler;    // always honor last known orientation
}



bool
ClientImpl::getPlacement
(
IN int playerId,
OUT placement_t& placement
)
{
        ASSERT(playerId > 0, "Bad player id: %d", playerId);
        placement.clear();

        client_player_record_t * prec = this->getPlayer(playerId);
        if (!prec || !prec->objectId) {
                return false;
        }

        // get position from object synchronizer
        object_state_t state;
        if (!m_syncMgr->getState(prec->objectId, state) ||
            !state.physicsObject) {
                return false;
        }
        placement.position = state.physicsObject->getPosition();

        // TODO: could get euler angles from physics object as well!
        // For now, we purposely don't trust the physics engine for that.
        // get euler angles from our local copy
        placement.rotation.setEulerZYX(prec->euler);

        // all done
        return true;
}



smart_ptr<PhysicsObject>
ClientImpl::getPlayerObject
(
IN int playerId
)
{
        ASSERT(playerId > 0, "Bad player id: %d", playerId);

        client_player_record_t * prec = this->getPlayer(playerId);
        if (!prec || !prec->objectId) {
        //      DPRINTF("No player object?");
                return NULL;
        }

        // okay, we have our object ID.  But this is the object ID on the
        //      server!  need to get local physics object...
        ASSERT(m_syncMgr, "null");
        object_state_t os;
        if (!m_syncMgr->getState(prec->objectId, os))
                return NULL;

        return os.physicsObject;
}



//
//      ClientImpl -- private helper methods
//

void
ClientImpl::notifySubmit
(
IN const char * id,
IN const Datahash * data
)
{
        ASSERT(id, "null");
        ASSERT(data, "null");

        DPRINTF("Received submit for conversation: %s", id);

        // look up this conversation
        converse_rec_t * cr = this->getConversation(id);
        if (!cr) {
                DPRINTF("Received submit for unknown conversation?");
                DPRINTF("  id='%s'", id);
                return;
        }

        // local?  Then we handle all the forwarding here
        if (!cr->connId) {
                DPRINTF("  Local conversation!");
                ASSERT(m_conversationMgr, "null");

                m_conversationMgr->handleDialogReplyTS(id, cr->dialogId,
                    0, cr->playerId, data);

                return;
        }

        // not local!  Need to tell server about the reply
        // construct reply
        std::ostringstream reply;
        writeHashToStream(data, reply);

        DPRINTF("Constructed reply:\n%s", reply.str().c_str());

        // tell the server!
        smart_ptr<MessageBuffer> msg =
            createConversationReplyMessage(cr->playerId, id, cr->dialogId,
            reply.str().c_str());

        netlib::enqueueMessage(m_tcpConnID, msg);
}



//
//      ClientImpl -- converse::ConversationRouter class interface methods
//

void
ClientImpl::routeConversationTS
(
IN const char * guid,
IN int dialogId,
IN int playerId,
IN conn_id_t connId,
IN const char * dialogData
)
{
        ASSERT(guid, "null");
        ASSERT(dialogId >= 0, "Bad dialog id: %d", dialogId);
        ASSERT(playerId > 0, "bad player id: %d", playerId);
        ASSERT(!connId, "Should only be used for local conversations!");
        ASSERT(dialogData, "null");
        ASSERT(m_host, "null");
        ASSERT(m_conversationMgr, "null");

        //DPRINTF("Routing conversation '%s', dialog=%d", guid, dialogId);

        // end of conversation?
        if (!dialogId) {
                DPRINTF("Destroying this conversation/dialog: %s", guid);
                this->deleteConversation(guid, playerId);
                return;
        }

        // update our view of dialog ID
        converse_rec_t * cr = this->getConversation(guid);
        if (!cr) {
                DPRINTF("Unable to find conversation: '%s'", guid);
        } else {
                cr->dialogId = dialogId;
        }

        // construct datahash with request
        std::istringstream iss(dialogData);
        smart_ptr<Datahash> hash = readHashFromStream("local dialog", iss);

        // forward dialog request
        m_host->requestDialog(guid, playerId, hash, this);
}



//
//      ClientImpl -- private helper methods
//

client_player_record_t *
ClientImpl::getPlayer
(
IN int id
)
{
        ASSERT(id > 0, "Bad input id: %d", id);

        player_map_t::iterator i = m_players.find(id);
        if (m_players.end() == i) {
                //DPRINTF("No player with id=%d", id);
                return NULL;
        }
        ASSERT(i->second, "null player in map");

        return i->second;
}



converse_rec_t *
ClientImpl::getConversation
(
IN const char * guid
)
{
        ASSERT(guid, "null");

        conversation_map_t::iterator i = m_conversations.find(guid);
        if (m_conversations.end() == i) {
                return NULL;            // conversation not found
        }

        return i->second;
}



void
ClientImpl::deleteConversation
(
IN const char * guid,
IN int playerId
)
{
        ASSERT(guid, "null");
        ASSERT(playerId > 0, "Bad player id: %d", playerId);

        conversation_map_t::iterator i = m_conversations.find(guid);
        if (m_conversations.end() == i) {
                DPRINTF("Cannot delete unknown conversation: %s", guid);
                return;
        }

        // real conversation!  Tell host
        ASSERT(m_host, "null");
        m_host->destroyDialog(guid, playerId);

        // clear map
        m_conversations.erase(guid);
}


// doxygen comment block


void
ClientImpl::checkHostState
(
void
)
{
        //DPRINTF("mode = %d", m_hMode);

        // walk through and assemble basic state
        ASSERT(eClientState_Invalid != m_clientState,
            "why is state invalid now?");

        // are we connected?
        if (m_remoteUdpConnID) {
                // yes!  (or at least connecting...)
                m_clientState = eClientState_Connecting;
        } else {
                m_clientState = eClientState_Searching;
                return;
        }

        // walk through our host state, and see if we need to enqueue messages
        if (eHostMode_Invalid == m_hMode) {
                // DPRINTF("Server doesn't know about us!");
                // server doesn't know anything about us!
                // are we already attempting to connect?
                if (m_netQueue->containsRequest(s_reqIdConnect))
                        return; // yup, keep trying

                // need to attempt to connect!  get our public key
                // DPRINTF("Attempting to connect to server...");
                ASSERT(m_rsaKey, "null");
                smart_ptr<crypto::RSAPublicKey> pubkey =
                    m_rsaKey->getPublicKey();
                ASSERT(pubkey, "null");
                std::string publicKey = pubkey->serialize();

                // create request context
                long token = m_remoteUdpConnID; // use remote UDP conn ID
                smart_ptr<netrq::Request> rc =
                    ConnectContext::create(token, m_localUdpPort,
                        publicKey.c_str());
                ASSERT(rc, "null");

                // add to network request queue
                m_netQueue->addRequest(m_udpClock + 1, rc);
                return;
        } else if (eHostMode_Connected == m_hMode && m_desKey) {
                DPRINTF("Connected!  Now need to authorize...");

                // need to authorize
                ASSERT(m_desKey, "null");

                // already attempting to authorize?
                if (s_authCountdown) {
                        --s_authCountdown;
                        return;
                }
                s_authCountdown = 10;

                // TODO: allow client to specify password
                DPRINTF("Sending host level password...");
                std::string encryptedPassword = m_desKey->encrypt("", 12);
                DPRINTF("Encrypted password: %s", encryptedPassword.c_str());
                smart_ptr<netrq::Request> rc =
                    new AuthorizeContext(encryptedPassword.c_str());
                m_netQueue->addRequest(m_udpClock + 1, rc);
                return;
        } else if (eHostMode_Authorized == m_hMode) {
                // looks good--make sure we have no auth requests pending
                // m_netQueue->removeRequest(s_reqIdAuthorize);
        }

        // don't do anything else unless host is authorized
        if (eHostMode_Authorized != m_hMode)
                return;

        // need to set up TCP connection?
        if (m_udpConnToken && !m_tcpConnID && m_serverTcpPort) {
                ASSERT2(m_server.isValid(), "Invalid server");
                netlib::address_t address = m_server.address;
                address.port = m_serverTcpPort;
                address.dump("Attempting TCP connection here");
                m_tcpConnID = netlib::createTcpConnection(address);
                ASSERT2(m_tcpConnID, "Failed to create TCP connection");

                // must provide the (UDP) token when making TCP connections
                smart_ptr<netlib::MessageBuffer> msg =
                    createTcpConnectMessage(m_udpConnToken);
                ASSERT(msg, "failed to create tcp connect message");
                netlib::enqueueMessage(m_tcpConnID, msg);
        }

        // connected?
        if (m_udpConnToken && m_tcpConnID && m_remoteUdpConnID) {
                m_clientState = eClientState_Connected;
        }
}



void
ClientImpl::handleMessage
(
IN const envelope_t& env,
IN const MessageBuffer * msg
)
{
        ASSERT(!env.is_empty(), "empty");
        ASSERT(msg, "null");

        // TODO: need a proper dispatch map here!
        if (netlib::eType_UDPRemote == env.type) {
                this->handleUDP(env, msg);
                return;
        }

        // TCP?  get payload
        tcp_payload_t payload;
        getTcpPayload(msg->getData(), payload);
        ASSERT(!payload.is_empty(), "empty");

        // dispatch based on type of message...
        const char * namespace_ = payload.namespace_.c_str();
        ASSERT(namespace_, "null");
        if (strcmp("client", namespace_)) {
                DPRINTF("Invalid message namespace: '%s'", namespace_);
                return;
        }

        const char * command = payload.command.c_str();
        ASSERT(command, "null");
        const Datahash * data = payload.arguments;
        ASSERT(data, "null");

        if (!strcmp(command, "converse-dialog")) {
                DPRINTF("Got a dialog request!");
                smart_ptr<Datahash> dialog = getSubhash(data, "dialog");
                int playerId = getInt(data, "playerId");
                if (playerId < 1) {
                        WAVE_EX(wex);
                        wex << "Bad player id: " << playerId;
                }
                std::string conGuid = getString(data, "conversationGuid");
                int dialogId = getInt(data, "dialogId");
                if (dialogId <= 0) {
                        WAVE_EX(wex);
                        wex << "Bad dialog id: " << dialogId;
                }

                // add to our conversation map
                smart_ptr<converse_rec_t> cr = new converse_rec_t;
                ASSERT(cr, "out of memory");
                cr->dialogId = dialogId;
                cr->playerId = playerId;
                cr->connId = m_tcpConnID;
                m_conversations[conGuid] = cr;

                // tell host to display
                m_host->requestDialog(conGuid.c_str(), playerId, dialog, this);
        } else if (!strcmp(command, "converse-end")) {
                DPRINTF("Got a request to end a conversation");
                std::string guid = getString(data, "conversationGuid");
                int playerId = getInt(data, "playerId");
                if (playerId < 1) {
                        WAVE_EX(wex);
                        wex << "Bad player id: " << playerId;
                }

                // destroy from map
                this->deleteConversation(guid.c_str(), playerId);

        } else if (!strcmp(command, "error")) {
                DPRINTF("Received error from server!");
                eErrorCode code = (eErrorCode) getLong(data, "errorCode");
                DPRINTF("  Error code: 0x%05x", code);
                std::string message = getString(data, "message");
                DPRINTF("  Message: %s", message.c_str());
                if (eErrorCode_Fatal & code) {
                        ASSERT(false, "Got fatal error, stopping: %s",
                            message.c_str());
                }

        } else {
                DPRINTF("Unknown command: '%s'", command);
        }
}



void
ClientImpl::handleUDP
(
IN const envelope_t& env,
IN const MessageBuffer * msg
)
{
        perf::Timer("clib::handleUDP");
        ASSERT(!env.is_empty(), "empty");
        ASSERT(msg, "null");

//      DPRINTF("Received %ld bytes from UDP", msg->getBytes());

        // resurrect as XDR input buffer
        ASSERT(m_udpIn, "should have input buffer now");
        m_udpIn->reset((const byte_t *) msg->getData(), msg->getBytes());

        // grab header
        xdrbuf::PackletHeader ph = m_udpIn->getNextPackletHeader();

        // is this a broadcast packet?
        if ('s' == ph.getName()) {
                this->handleBroadcast(ph, env);
                return;
        }

        // not a broadcast packet?  Assume it is a standard state packet
        if ('h' != ph.getName()) {
                DPRINTF("Malformed input UDP packet?");
                return;
        }

        // are we even allowed to handle UDP packets?
        if (eClientState_Connected != m_clientState &&
            eClientState_Connecting != m_clientState) {
                DPRINTF("Ignoring incoming UDP packets");
                return;
        }

        // header is 6 longs right now
        //   1: token
        //   2: server clock
        //   3: last client udp clock the server received
        //   4: server state
        //   5: host state
        //   6: server TCP listening port
        int32_t l[6];
        m_udpIn->readInt32s(l, 6);

        // verify that sender is legit
        dword_t token = l[0];
        netlib::connection_info_t ci;
        if (!netlib::getConnectionInfo(token, ci)) {
                DPRINTF("Input udp connection token is invalid");
                return;
        }
        if (ci.address.ip != env.address.ip) {
                DPRINTF("UDP sender does not match connection token");
                DPRINTF("From token:");
                ci.address.dump("  our record");
                DPRINTF("From envelope:");
                env.address.dump("  msg record");
                return;
        }

        // appears to be a legit UDP packet from server!

        // is this a stale clock?
        dword_t clock = l[1];
        if (clock < m_udpMostRecentClock) {
                DPRINTF("Message is old!");
                return;
        }
        m_udpMostRecentClock = clock;
//      DPRINTF("Most recent clock: %lu", m_udpMostRecentClock);

        // what was the last message of ours the server saw?
        m_lastUdpServerSaw = l[2];
        dword_t delta = m_udpClock - m_lastUdpServerSaw;
        if (delta > 3) {
                DPRINTF("Server is %lu messages behind!", (long) delta);
        }

        // update local state based on this state from server
        eServerMode smode = (eServerMode) l[3];
        ASSERT(eServerMode_Idle == smode, "mode: %d", smode);
        m_hMode = (eHostMode) l[4];

        // remember server's TCP port
        if (m_serverTcpPort != l[5]) {
                DPRINTF("Got new server TCP port!");
                if (m_tcpConnID) {
                        netlib::closeConnection(m_tcpConnID);
                        m_tcpConnID = 0;
                }
                m_serverTcpPort = l[5];
        }

        // parse packlets
        while (!m_udpIn->endOfStream()) {
                xdrbuf::PackletHeader ph = m_udpIn->getNextPackletHeader();
                char name = ph.getName();
//              DPRINTF("  Found packlet with name '%c'", name);

                switch (name) {

                case 'c':
                        this->readConnectUDP(m_udpIn);
                        break;

                case 'd':
                        this->readDestroyUDP(m_udpIn);
                        break;

                case 'o':
                        this->readObjectUDP(m_udpIn);
                        break;

                case 'p':
                        this->readPlayerUDP(m_udpIn);
                        break;

                case 'q':
                        this->readQueryUDP(ph, m_udpIn);
                        break;

                default:
                        {
                                WAVE_EX(wex);
                                wex << "Unknown packlet name: '" << name << "'";
                        }
                }
        }
}



void
ClientImpl::handleBroadcast
(
IN xdrbuf::PackletHeader ph,
IN const envelope_t& env
)
{
//      DPRINTF("Handing UDP broadcast");

        const int bufsize = 255;
        char buffer[bufsize + 1];

        // construct local server info object
        server_info_t si;
        std::string uuid;
        int port = 0;

        // NOTE: we assume the caller already read the first packlet header, and
        //      that's what was passed in.
        bool firstPass = true;

        // parse packlets
        while (!m_udpIn->endOfStream()) {
                char name = 's';
                if (!firstPass) {
                        ph = m_udpIn->getNextPackletHeader();
                        name = ph.getName();
                }
                firstPass = false;
        //      DPRINTF("  Found packlet with name '%c'", name);

                switch (name) {
                case 's':               // public server name
                        {
                                int len = ph.getDataCount();
                                ASSERT2(len <= bufsize, "server public name is "
                                    << "too big: " << len << " characters");
                                m_udpIn->readString(buffer, len);
                                buffer[len] = 0;        // null terminate
                                si.publicName = buffer;
                        }
                        break;

                case 'u':               // story UUID
                        {
                                int len = ph.getDataCount();
                                ASSERT2(len <= bufsize, "server UUID is "
                                    << "too big: " << len << " characters");
                                m_udpIn->readString(buffer, len);
                                buffer[len] = 0;        // null terminate
                                uuid = buffer;
                        }
                        break;

                case 'p':               // server UDP port
                        {
                                int32_t i32;
                                m_udpIn->readInt32s(&i32, 1);
                                port = i32;
                        }
                        break;

                default:
                        {
                                // got something we didn't recognize?  Abandon
                                //      parsing, but don't throw.  Could be
                                //      garbage broadcasts on network.
                                DPRINTF("Unknown packlet in broadcast: '%c'",
                                    name);
                                return;         // just return
                        }
                }
        }

        // did we get a valid server UDP port?
        if (port < 1) {
                DPRINTF("Unspecified or invalid port: %d", port);
                return;
        }

        // set up address
        si.address = env.address;
        si.address.port = port;
        if (!si.isValid()) {
                DPRINTF("Invalid server information--ignoring broadcast");
                return;
        }

        // can we use this?
        if (strcmp(uuid.c_str(), m_story->getUuid())) {
                DPRINTF("Ignoring broadcast from server with different story.");
                DPRINTF("  Our uuid: '%s'", m_story->getUuid());
                DPRINTF("  Server uuid: '%s'", uuid.c_str());
                si.address.dump("  Server address");
                return;
        }

        // yes, appears to match!
        // DPRINTF("Got a valid server broadcast packet!");
        getServerHashKey(si, buffer);
        // DPRINTF("  hash key: '%s'", buffer);

        // insert (or overwrite)
        m_servers.insert(buffer, si);
        // DPRINTF("Have discovered %d servers", m_servers.size());
}



void
ClientImpl::readConnectUDP
(
IO xdrbuf::Input * input
)
{
        ASSERT(input, "null");

        // should get token now
        xdrbuf::PackletHeader ph = input->getNextPackletHeader();
        if ('t' != ph.getName() || xdrbuf::ePacklet_Int32s != ph.getType()) {
                WAVE_EX(wex);
                wex << "Invalid packlet while parsing connection response";
        }
        input->readInt32s((int32_t *) &m_udpConnToken, 1);

        // server is sending us the encrypted DES key
        ph = input->getNextPackletHeader();
        if ('k' != ph.getName() ||
            xdrbuf::ePacklet_ParentBegin != ph.getType()) {
                WAVE_EX(wex);
                wex << "Invalid packlet when expecting encrypted DES key";
        }
        int maxSize = 1024;
        char buffer[maxSize];
        char * offset = buffer;
        int read = 0;

        while (true) {
                xdrbuf::PackletHeader ph = input->getNextPackletHeader();
                if ('k' == ph.getName() &&
                    xdrbuf::ePacklet_ParentEnd == ph.getType())
                        break;          // end of des key

                if (xdrbuf::ePacklet_String != ph.getType()) {
                        WAVE_EX(wex);
                        wex << "Invalid packlet while reading des key";
                }

                int bytes = ph.getDataCount();
                if (read + bytes > maxSize - 1) {
                        WAVE_EX(wex);
                        wex << "Encrypted DES key is too big!";
                }

                input->readString(offset, bytes);
                read += bytes;
                offset += bytes;
        }
        buffer[read] = 0;               // null-terminate

        // that should be it
        ph = input->getNextPackletHeader();
        if ('c' != ph.getName() || xdrbuf::ePacklet_ParentEnd != ph.getType()) {
                WAVE_EX(wex);
                wex << "Expected end of connection response packlet";
        }

        // okay, have the encrypted DES key.  Decrypt!
        this->setKeys(buffer);
}



void
ClientImpl::readDestroyUDP
(
IO xdrbuf::Input * input
)
{
        ASSERT(input, "null");

        // object has been destroyed!  which one?
        dword_t objectId;
        input->readInt32s((int32_t *) &objectId, 1);
        if (objectId < 1) {
                WAVE_EX(wex);
                wex << "Bad object ID: " << objectId;
        }

        //DPRINTF("We've been asked to remove object: %ld", objectId);

        // remove this from our map!
        m_syncMgr->removeObject(objectId);
}



void
ClientImpl::readPlayerUDP
(
IO xdrbuf::Input * inbuf
)
{
        ASSERT(inbuf, "null");

        // DPRINTF("Got player data");

        // at the moment, player state is a set of 3 longs
        int32_t l[3];
        inbuf->readInt32s(l, 3);

        // this is data we care about
        int playerId = (int) l[0];
//      int state = (int) l[1]; // basically ignore this for now...
        dword_t objectId = l[2];

        // okay, examine the data
        if (playerId < 1) {
                WAVE_EX(wex);
                wex << "Bad player id from server: " << playerId;
        }

        client_player_record_t * cpr = this->getPlayer(playerId);
        if (!cpr) {
                DPRINTF("Server has player we don't?: %d", playerId);
                return;
        }
        ASSERT(cpr, "null");

        // update with object ID
        cpr->objectId = objectId;

        //DPRINTF("Player %d has object ID %u", playerId, objectId);

        // get current state for this object
        ASSERT(m_syncMgr, "null");
        ASSERT(m_host, "null");
        if (!objectId) {
                // player is not bound to an object, therefore not in map!
                smart_ptr<MapDynamics> nullMap;
                m_host->notifyPlayerMap(playerId, nullMap);
                return;
        }

        // okay, player is bound to an object.  Get the state if possible
        object_state_t state;
        if (!m_syncMgr->getState(objectId, state)) {
                return; // player is bound, but object is uninitialized
        }

        // tell host about map, in case it changed
        m_host->notifyPlayerMap(playerId, state.dyn);
}



void
ClientImpl::readQueryUDP
(
IN const xdrbuf::PackletHeader& ph_in,
IO xdrbuf::Input * input
)
{
        ASSERT(input, "null");

        DPRINTF("Got query response");

        // this is the response to an object query that we sent the server

        // verify this is a well-formed packlet
        if (xdrbuf::ePacklet_ParentBegin != ph_in.getType()) {
                WAVE_EX(wex);
                wex << "invalid (non-parent) packlet type for query response";
        }

        // next packlet should be ID
        dword_t objectId;
        xdrbuf::PackletHeader ph = input->getNextPackletHeader();
        if ('i' != ph.getName() ||
            xdrbuf::ePacklet_Int32s != ph.getType() ||
            1 != ph.getDataCount()) {
                WAVE_EX(wex);
                wex << "invalid object ID packlet in query response";
        }
        input->readInt32s((int32_t *) &objectId, 1);

        // next packlet should be typeID
        ph = input->getNextPackletHeader();
        int c = ph.getDataCount();
        if ('t' != ph.getName() ||
            xdrbuf::ePacklet_String != ph.getType() ||
            c > eAESOP_MaxIdLength) {
                WAVE_EX(wex);
                wex << "invalid object type ID in query response";
        }
        char buffer[eAESOP_IdBufferSize];
        input->readString(buffer, c);
        buffer[c] = 0;  // force null-termination

        // next packlet should be mapID
        ph = input->getNextPackletHeader();
        c = ph.getDataCount();
        if ('m' != ph.getName() ||
            xdrbuf::ePacklet_String != ph.getType() ||
            c > eAESOP_MaxIdLength) {
                WAVE_EX(wex);
                wex << "invalid map ID in query response";
        }
        char mapId[eAESOP_IdBufferSize];
        input->readString(mapId, c);
        mapId[c] = 0;   // force null-termination

        // and next should be the close
        ph = input->getNextPackletHeader();
        if ('q' != ph.getName() ||
            xdrbuf::ePacklet_ParentEnd != ph.getType()) {
                WAVE_EX(wex);
                wex << "Unrecognized packlet in query response";
        }

        // okay, have ID and type ID.  Update
        DPRINTF("Have a type ID for object %ld: '%s'",
            (long) objectId, buffer);
        DPRINTF("  mapId = '%s'", mapId);
        m_syncMgr->setTypeId(objectId, buffer);
        m_syncMgr->setMapId(objectId, mapId);

        // remove any pending requests for this
        sprintf(buffer, "qo%ld", (long) objectId);
        m_netQueue->removeRequest(buffer); 
}



void
ClientImpl::readObjectUDP
(
IO xdrbuf::Input * inbuf
)
{
        ASSERT(inbuf, "null");

        // DPRINTF("Object update");

        // prepare to read object information
        dword_t objectId = 0;
        state_update_t update;
        bool havePosition = false;
        bool haveAnimation = false;

        const int bufsize = 512;
        char buffer[bufsize];
        buffer[0] = 0;

        // object is structured, keep parsing
        bool halt = false;
        while (!halt) {
                xdrbuf::PackletHeader ph = inbuf->getNextPackletHeader();
                char name = ph.getName();

                switch (name) {
                case 'i':
                        // this is the ID
                        inbuf->readInt32s((int32_t *) &objectId, 1);
                        break;

                case 'p':
                        // this is the position
                        inbuf->readFloats(&update.position.x, 3);
                        havePosition = true;
                        break;

                case 'o':
                        // orientation or end of object!
                        if (xdrbuf::ePacklet_ParentEnd == ph.getType()) {
                                halt = true;
                        } else {
                                inbuf->readFloats(&update.orientation.x, 4);
                        }
                        break;

                case 'l':
                        // linear velocity
                        inbuf->readFloats(&update.linear.x, 3);
                        break;

                case 'a':
                        // angular velocity
                        inbuf->readFloats(&update.angular.x, 3);
                        break;

                case 'n':
                        // animation state
                        {
                                int len = ph.getDataCount();
                                if (len >= bufsize) {
                                        DPRINTF("ERROR: animation state too big?");
                                } else {
                                        haveAnimation = true;
                                        inbuf->readString(buffer, len);
                                        buffer[len] = 0;
                                        //DPRINTF("Read animation state: '%s'",
                                        //    buffer);
                                }
                        }
                        break;

                default:
                        {
                                WAVE_EX(wex);
                                wex << "Unrecognized packlet name '" << name;
                                wex << "' while parsing map object";
                        }
                }
        }

        // verify what we received
        if (!objectId) {
                WAVE_EX(wex);
                wex << "No or null object ID received";
        }
        if (!havePosition) {
                WAVE_EX(wex);
                wex << "No position received for object: " << objectId;
        }

        //DPRINTF("Server said we are object: %ld", objectId);

        // okay, have updated object position!  Update state
        ASSERT(m_syncMgr, "null");
        m_syncMgr->serverUpdate(objectId, m_lastUdpServerSaw, update);

        // have a physics object?
        object_state_t state;
        ASSERT(m_syncMgr->getState(objectId, state),
            "Just updated this object, it should exist!  id=%lu",
            (long) objectId);
        if (state.physicsObject) {
                // attempt to update animation
                if (haveAnimation) {
                        m_host->updateAnimation(state.physicsObject, buffer);
                }
                return;         // good, all set
        }

//      DPRINTF("Need a physics object!");

        // request more info about object from server
        smart_ptr<netrq::Request> ctx = QueryObjectRequest::create(objectId);
        ASSERT(ctx, "null");

        // add this request to our network request queue
        if (netrq::Queue::eQueue_Success == m_netQueue->addRequest(m_udpClock + 3, ctx)) {
                ASSERT(ctx.get_ref_count() > 1, "bad ref count");
        }
}



void
ClientImpl::setKeys
(
IN const char * encryptedDesKey
)
{
        ASSERT(encryptedDesKey, "null");

        std::string desKey = m_rsaKey->decrypt(encryptedDesKey);
        DPRINTF("decrypted DES key: %s", desKey.c_str());

        m_desKey = crypto::DESKey::create(desKey.c_str());
        ASSERT(m_desKey, "null");

        // notify host!
        m_host->notifyKey(m_desKey);
}



// **** KEEP THIS COMMENT BLOCK ***


void
ClientImpl::sendUdpPacket
(
IN float dt
)
{
        perf::Timer timer("Client::sendUdpPacket");
        ASSERT(dt > 0.0, "Bad time delta: %f", dt);
        ASSERT(m_udpOut, "Should have a udp output buffer by now");
        if (!m_remoteUdpConnID) {
                return;         // don't yet have a UDP connection with server
        }

        // update our udp clock
        ++m_udpClock;

        // let synchronizer add requests to outgoing request queue
        m_syncMgr->addRequests(m_netQueue, m_udpClock);

        // this is where we send all interesting (dynamic) client state up to
        // the server.
        m_udpOut->clear();      // reset output buffer

        // send header first.  This is 2 longs
        //    0: token
        //    1: our udp clock value
        int32_t l[3];
        l[0] = m_udpConnToken;
        l[1] = m_udpClock;
        m_udpOut->addInt32Packlet('h', l, 2);   // 'h' -- header

        if (eHostMode_Authorized == m_hMode) {
        // loop through all players and send per-player information
        for (player_map_t::iterator i = m_players.begin(); i != m_players.end();
             ++i)
        {
                int id = i->first;
                client_player_record_t * pr = i->second;
                ASSERT(pr, "null player record in map");

                // open a packlet for this player record
                m_udpOut->openPacklet('p');

                // send ID
                dword_t dwId = id;
                m_udpOut->addInt32Packlet('i', (int32_t *) &dwId, 1);

                // send the desired motion (move by delta over time interval dt)
                object_state_t state;
                if (pr->objectId &&
                    m_syncMgr->getState(pr->objectId, state) &&
                    state.physicsObject) {
                        // we send 7 floats to represent position and orientation
                        // TODO: trim this down somehow?  lower resolution?
                        // Doesn't matter much for sending data up
                        float f[7];
                        f[0] = pr->delta.x; // first 3 floats: position delta
                        f[1] = pr->delta.y;
                        f[2] = pr->delta.z;
                        f[3] = dt;          // fourth float: time delta
                        f[4] = pr->euler.x; // last 3 floats: euler angles
                        f[5] = pr->euler.y;
                        f[6] = pr->euler.z;
                        m_udpOut->addFloatPacklet('m', f, 7);

                        // now that we've sent the delta to the server, reset
                        pr->delta.clear();
                }

                // all done with player record
                m_udpOut->closePacklet('p');
        }
        }

        // add any pending messages
//      DPRINTF("Looking for pending messages");
        netrq::sendMessagesFromQueue(m_udpOut, m_udpClock, m_netQueue);

        // final step: allow host to send game data
        m_udpOut->openPacklet('g');     // 'g' -- game data
        {
                perf::Timer timer("appendGameData");
                m_host->appendGameData(m_udpOut);
        }
        m_udpOut->closePacklet('g');

        // all done with message construction
//      DPRINTF("  done!");
        // TODO: no allocations here!  Pull message buffer from freelist
        smart_ptr<MessageBuffer> mb = MessageBuffer::create();
        ASSERT(mb, "failed to create message buffer");
        const byte_t * pb = m_udpOut->getData();
        int bytes = m_udpOut->getDataBytes();
        ASSERT(bytes > 0, "Bad udp byte count: %d", bytes);
        mb->reserve(bytes);
        mb->appendData((const char *) pb, bytes);
        mb->close();

        // send udp message
        netlib::enqueueMessage(m_remoteUdpConnID, mb);
}



//
//      factory methods
//

smart_ptr<Client>
Client::create
(
IN ClientHost * host,
IN smart_ptr<story::Story>& story,
IN smart_ptr<Datahash>& params
)
{
        ASSERT(host, "null");
        ASSERT(story, "null");
        ASSERT(params, "null");

        smart_ptr<ClientImpl> local = new ClientImpl;
        ASSERT(local, "null");

        local->initialize(host, story, params);

        return local;
}



};      // aesop namespace