converse-new-player.cpp

Go to the documentation of this file.

/*
 * converse-new-player.cpp
 *
 * Copyright (C) 2008,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.
 *
 * Handles conversation for new players.
 */

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

#include "srv-hosts.h"
#include "srv-msg-router.h"
#include "srv-users.h"

#include "common/wave_ex.h"
#include "crypto/crypto.h"
#include "datahash/datahash_util.h"
#include "dialog/request.h"
#include "perf/perf.h"


namespace aesop {



enum eDialogs {
        eDialog_First           = 1,            // initial screen
        eDialog_SignIn          = 2,            // provide password
        eDialog_Create          = 3,            // create new user account
        eDialog_Fail            = 4,            // notify failure!

        // keep this last!
        eDialog_Done            = 0
};



//
//      NPHost -- implements the ConversationHost interface for New Player
//                      conversations.
//

class NPHost : public converse::ConversationHost {
public:
        NPHost(void) throw();
        ~NPHost(void) throw() { }

        // public class methods ------------------------------------------------
        void initialize(IN smart_ptr<crypto::DESKey>& desKey,
                                IN new_player_conv_data_t& data);

        // aesop::ConversationHost class interface methods --------------------
        int getCurrentDialogIdTS(void);
        void handleReplyTS(IN int dialogId,
                                IN const Datahash * reply);
        std::string getDialogDataTS(void);

private:
        // private helper methods ----------------------------------------------

        // private member data -------------------------------------------------
        smart_ptr<crypto::DESKey>       m_desKey;
        new_player_conv_data_t  m_data;
        int                     m_dialog;       // where are we?
        std::string             m_header;
        std::string             m_username;     // player is attempting to be
        std::string             m_diagnostic;
};



NPHost::NPHost(void)
throw()
{
        m_dialog = eDialog_First;
}



void
NPHost::initialize
(
IN smart_ptr<crypto::DESKey>& desKey,
IN new_player_conv_data_t& data
)
{
        ASSERT(desKey, "null");
        ASSERT(data.isValid(), "invalid new player data");

        ASSERT(!m_desKey, "Already have symmetric encryption key?");
        m_desKey = desKey;

        m_data = data;
        ASSERT(m_data.isValid(), "copied data is invalid?");

        // other info
        const int bufSize = 64;
        char buffer[bufSize];
        gethostname(buffer, bufSize - 1);
        buffer[bufSize - 1] = 0;        // force null

        m_header = "Server: ";
        m_header += buffer;
}



//
//      NPHost -- aesop::ConversationHost class interface methods
//

int
NPHost::getCurrentDialogIdTS
(
void
)
{
        return m_dialog;
}



void
NPHost::handleReplyTS
(
IN int dialogId,
IN const Datahash * reply
)
{
        ASSERT(dialogId > 0, "Bad dialog id: %d", dialogId);
        ASSERT(reply, "null");
        ASSERT(m_data.isValid(), "invalid new player data");

        std::string submit = getString(reply, "submit");
        DPRINTF("Received submit='%s' for dialog=%d", submit.c_str(), dialogId);
        std::string password;

        if (dialogId != m_dialog) {
                // player had wrong version!  Do nothing and force refresh
                // conversation framework should catch this...  threading issue?
                DPRINTF("ERROR: called on wrong dialog id?");
                return;
        }

        // determine next state
        if (eDialog_First == m_dialog) {
                if ("_new" == submit) {
                        m_dialog = eDialog_Create;
                } else {
                        m_username = submit;
                        // selected a user account: need to sign in?
                        if (m_data.userMgr->passwordRequiredTS()) {
                                m_dialog = eDialog_SignIn;
                        } else {
                                m_dialog = eDialog_Done;
                        }
                }
        } else if (eDialog_SignIn == m_dialog) {
                std::string enc = getString(reply, "password");
//              DPRINTF("Encrypted password: %s", enc.c_str());
                password = m_desKey->decrypt(enc.c_str());
                m_dialog = eDialog_Done;
        } else if (eDialog_Create == m_dialog) {
                std::string username = getString(reply, "username");
                if (m_data.userMgr->createUserTS(username.c_str(), m_diagnostic)) {
                        // success!
                        m_username = username;
                        if (m_data.userMgr->passwordRequiredTS()) {
                                m_dialog = eDialog_SignIn;
                        } else {
                                m_dialog = eDialog_Done;
                        }
                } else {
                        // failure!
                        DPRINTF("Failed: %s", m_diagnostic.c_str());
                        m_dialog = eDialog_Fail;
                }
        } else if (eDialog_Fail == m_dialog) {
                // don't care what was submitted!  Just start over
                m_dialog = eDialog_First;
        } else {
                m_dialog = eDialog_Done;
        }

        // think we're done?  Try it...
        if (eDialog_Done == m_dialog) {
                // attempt to log in with current credentials
                std::string playerGuid;
                if (!m_data.userMgr->logInAsUserTS(m_username.c_str(),
                    password.c_str(), playerGuid, m_diagnostic)) {
                        DPRINTF("Failed!  %s", m_diagnostic.c_str());
                        m_dialog = eDialog_Fail;
                } else {
                        // logged in!
                        DPRINTF("Player guid: '%s'", playerGuid.c_str());

                        // will server allow it?
                        if (!m_data.updates->setPlayerUserAccountTS(
                            m_data.connId, m_data.playerId, m_username.c_str(),
                            playerGuid.c_str(), m_diagnostic)) {
                                DPRINTF("Server disallowed: %s",
                                    m_diagnostic.c_str());
                                m_dialog = eDialog_Fail;
                        }
                }
        }
}



std::string
NPHost::getDialogDataTS
(
void
)
{
        ASSERT(m_data.isValid(), "invalid new player data");

        // quick check
        if (eDialog_Done == m_dialog)
                return "";

        dialog::ContainerRequest c;
        c.addLabel(m_header.c_str());
        if (eDialog_First == m_dialog) {
                c.addLabel("Select a user account");
                SetString names;
                m_data.userMgr->getUsernamesTS(names);
                for (SetString::iterator i = names.begin(); i != names.end();
                     ++i) {
                        const char * login = i->c_str();
                        c.addButton(login, login);
                }
                if (m_data.userMgr->canCreateNewUsersTS()) {
                        c.addButton("_new", "New User");
                }
        } else if (eDialog_SignIn == m_dialog) {
                std::string text = "Provide password for ";
                text += m_username;
                c.addLabel(text.c_str());
                c.addTextbox("password", "", 8, true);
        } else if (eDialog_Create == m_dialog) {
                c.addLabel("Provide new username");
                c.addTextbox("username", "", 8);
        } else if (eDialog_Fail == m_dialog) {
                std::string error = "Error: ";
                error += m_diagnostic;
                c.addLabel(error.c_str());
                c.addButton("retry", "Retry");
        } else {
                ASSERT(false, "bad dialog id? %d", m_dialog);
        }

        return c.get();
}




//
//      NPHost -- private helper methods
//


//
//      public API
//

smart_ptr<converse::ConversationHost>
createNewPlayerConversationHost
(
IN smart_ptr<crypto::DESKey>& desKey,
IN new_player_conv_data_t& data
)
{
        ASSERT(desKey, "null");
        ASSERT(data.isValid(), "invalid new player data");

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

        local->initialize(desKey, data);

        return local;
}



};      // aesop namespace