srv-users.cpp

Go to the documentation of this file.

/*
 * srv-users.cpp
 *
 * Copyright (C) 2008  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.
 *
 * User/Player management.  See srv-users.h
 */

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

#include <dirent.h>

#include "common/wave_ex.h"
#include "crypto/crypto.h"
#include "datahash/datahash_text.h"
#include "datahash/datahash_util.h"
#include "perf/perf.h"
#include "threadsafe/threadsafe_map.h"
#include "util/file.h"


namespace aesop {


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


// min/max username.  Max is interesting!  It should be capable of 1e9
// usable names at least.  The limit of 15 was chosen so that a static char
// buffer (with null terminator) could be held in 16 bytes.
static const int s_minUsernameLength            = 3;
static const int s_maxUsernameLength            = 15;


static const char * s_configFilename            = "user-db.config";



//
//      UserMgr -- object that implements the UserManager interface
//

class UserMgr : public UserManager {
public:
        UserMgr(void) throw();
        ~UserMgr(void) throw() { }

        // public class methods ------------------------------------------------
        void initialize(IN const Datahash * params);

        // aesop::UserManager class interface methods -------------------------
        bool canCreateNewUsersTS(void) const throw() { return m_canCreateNewUsers; }
        bool passwordRequiredTS(void) const throw() { return m_passwordRequired; }
        void getUsernamesTS(OUT SetString& names);
        bool logInAsUserTS(IN const char * username,
                                IN const char * password,
                                OUT std::string& playerGuid,
                                OUT std::string& diagnostic);
        bool createUserTS(IN const char * username,
                                OUT std::string& diagnostic);
        bool isAdminTS(IN const char * username);

private:
        // private typedefs ----------------------------------------------------
        typedef threadsafe_map<std::string, long> user_map_t;

        // private helper methods ----------------------------------------------
        void getUserPath(IN const char * username,
                                OUT std::string& path);

        // private member data -------------------------------------------------
        std::string                     m_userDir;
        user_map_t                      m_userMap;
        smart_mutex                     m_mutex;
        bool                            m_canCreateNewUsers;
        bool                            m_passwordRequired;
};



UserMgr::UserMgr(void)
throw()
{
}



void
UserMgr::initialize
(
IN const Datahash * params
)
{
        ASSERT(params, "null");

        m_userDir = getString(params, "userDir");
        DPRINTF("Using user directory = %s", m_userDir.c_str());

        // read config file for local user database
        std::string configFile = m_userDir;
        configFile += "/";
        configFile += s_configFilename;

        DPRINTF("  Loading user db policies from file: %s", configFile.c_str());

        smart_ptr<Datahash> config = readHashFromTextFile(configFile.c_str());
        ASSERT(config, "null");

        // determine policies
        m_canCreateNewUsers = getBoolean(config, "canCreateNewUsers");
        m_passwordRequired = getBoolean(config, "passwordRequired");
}



//
//      UserMgr -- aesop::UserManager class interface methods
//

void
UserMgr::getUsernamesTS
(
OUT SetString& names
)
{
        perf::Timer timer("UserManager::getUsernames");
        // threadsafe!

        names.clear();          // clear before returning

        // we read the directory from scratch each time
        DIR * d = opendir(m_userDir.c_str());
        if (!d) {
                WAVE_EX(wex);
                wex << "Failed to open user directory for reading: ";
                wex << m_userDir;
        }

        // parse entries
        while (dirent * entry = readdir(d)) {
                if ('.' == entry->d_name[0])
                        continue;       // skip entries beginning with '.' 

                if (strcmp("user", GetExtension(entry->d_name)))
                        continue;       // must end in ".user"

                std::string login;
                GetFileRoot(entry->d_name, login);
                if (!isValidUsername(login.c_str())) {
                        DPRINTF("Invalid username: %s", login.c_str());
                        continue;       // skip invalid
                }

                // okay!
                names.insert(login);
        }
}



bool
UserMgr::logInAsUserTS
(
IN const char * username,
IN const char * password,
OUT std::string& playerGuid,    
OUT std::string& diagnostic     
)
{
        perf::Timer timer("UserManager::logInAsUser");
        ASSERT(username, "null");
        ASSERT(password, "null");
        playerGuid = "";
        diagnostic = "";

        if (!isValidUsername(username)) {
                diagnostic = "Username has invalid format";
                return false;
        }

        // construct filename
        std::string filename;
        this->getUserPath(username, filename);

        // read user file (throws if user does not exist)
        smart_ptr<Datahash> hash = readHashFromTextFile(filename.c_str());
        ASSERT(hash, "null");

        // require a password?
        if (this->passwordRequiredTS()) {
                // do we have a password?
                if (!password || !*password) {
                        diagnostic = "Password required but none provided?";
                        return false;
                }

                // must hash username + password
                // (this way two users with the same password won't realize it)
                std::string to_hash = username;
                to_hash += ":";
                to_hash += password;

                std::string in_sha1 = crypto::getSHA1(to_hash.c_str());
                // DPRINTF("hashed password: %s", in_sha1.c_str());

                // does user file contain password?
                if (hash->count("password")) {
                        std::string file_pw = getString(hash, "password");
                        if (file_pw != in_sha1) {
                                diagnostic = "Invalid password";
                                return false;
                        }
                        // passwords match!
                } else {
                        // user file does not contain password!
                        DPRINTF("Setting password for user: %s", username);
                        hash->insert("password", in_sha1.c_str());
                        writeHashToTextFile(hash, filename.c_str());
                }
        }

        // got here?  Logged in fine!  Create player GUID
        mlock lock(m_mutex);    // lock it down--messing with ref counting

        long count;
        if (!m_userMap.lookup(username, count)) {
                count = 0;
        } else {
                ++count;
        }
        DPRINTF("Count for '%s': %ld", username, count);
        playerGuid = username;
        if (count) {
                char buffer[64];
                sprintf(buffer, "%ld", count);
                playerGuid += buffer;
        }
        m_userMap.insert(username, count);

        DPRINTF("Tag: %s", playerGuid.c_str());

        return true;
}



bool
UserMgr::createUserTS
(
IN const char * username,
OUT std::string& diagnostic
)
{
        perf::Timer timer("UserManager::createUser");
        ASSERT(username, "null");
        diagnostic = "";

        // valid username?
        if (!isValidUsername(username)) {
                diagnostic = getUsernameRestrictions();
                return false;
        }

        // construct path
        std::string path;
        this->getUserPath(username, path);

        // verify does not exist
        if (doesPathExist(path.c_str())) {
                diagnostic = "Username '";
                diagnostic += username;
                diagnostic += "' already exists.";
                return false;
        }

        // create!
        createEmptyFileIfDoesNotExist(path.c_str());
        return true;
}



bool
UserMgr::isAdminTS
(
IN const char * username
)
{
        ASSERT(username, "null");

        std::string path;
        this->getUserPath(username, path);

        smart_ptr<Datahash> hash = readHashFromTextFile(path.c_str());
        ASSERT(hash, "null");

        std::string isAdmin = getOptionalString(hash, "isAdmin", "false");
        return getBooleanValueFromString(isAdmin.c_str());
}



//
//      UserMgr -- private helper methods
//

void
UserMgr::getUserPath
(
IN const char * username,
OUT std::string& path
)
{
        ASSERT(username, "null");

        path = m_userDir;
        path += "/";
        path += username;
        path += ".user";
}



//
//      public API
//

smart_ptr<UserManager>
UserManager::create
(
IN const Datahash * params
)
{
        ASSERT(params, "null");

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

        local->initialize(params);

        return local;
}



bool
isValidUsername
(
IN const char * username
)
{
        ASSERT(username, "null");

        int len = strlen(username);
        if (len < s_minUsernameLength || len > s_maxUsernameLength) {
                return false;
        }

        for (; *username; ++username) {
                if (*username < 'a' || *username > 'z')
                        return false;
        }

        return true;
}



std::string
getUsernameRestrictions
(
void
)
{
        std::ostringstream oss;
        oss << "Usernames can contain only lower-case characters, and must be ";
        oss << s_minUsernameLength << " to " << s_maxUsernameLength;
        oss << " characters long.";

        return oss.str();
}



};      // aesop namespace