account.cpp

Go to the documentation of this file.

/*
 * Crossfire -- cooperative multi-player graphical RPG and adventure game
 *
 * Copyright (c) 1999-2014 Mark Wedel and the Crossfire Development Team
 * Copyright (c) 1992 Frank Tore Johansen
 *
 * Crossfire is free software and comes with ABSOLUTELY NO WARRANTY. You are
 * welcome to redistribute it under certain conditions. For details, please
 * see COPYING and LICENSE.
 *
 * The authors can be reached via e-mail at <crossfire@metalforge.org>.
 */
 
#include <set>
 
#include "global.h"
 
static std::set<std::string> accounts_logged_in = std::set<std::string>();
 
#include <ctype.h>
#include <stdlib.h>
#include <string.h>
 
#include "object.h"
#include "sproto.h"
 
#include "output_file.h"
 
#define NUM_ACCOUNT_FIELDS 6
 
struct account_struct {
    char  *name;                    
    char  *password;                
    time_t last_login;              
    int   num_characters;           
    int   allocated_characters;     
    char  **character_names;        
    time_t  created;                
};
 
static std::vector<account_struct *> accounts;
 
static int accounts_loaded = 0;
 
#define ACCOUNT_FILE "accounts"
 
static void ensure_available_characters(account_struct *account, int count) {
    if (count >= account->allocated_characters) { // The list is NULL-terminated
        const int pa = account->allocated_characters;
        account->allocated_characters = count + 1;
        account->character_names = static_cast<char **>(realloc(account->character_names, account->allocated_characters * sizeof(account->character_names[0])));
        if (!account->character_names) {
            LOG(llevError, "Unable to allocate %d characters names!", account->allocated_characters);
            fatal(OUT_OF_MEMORY);
        }
        for (int i = pa; i < account->allocated_characters; i++) {
            account->character_names[i] = NULL;
        }
    }
}
 
static account_struct *account_alloc() {
    account_struct *ac = (account_struct *)calloc(1, sizeof(account_struct));
    if (!ac) {
        LOG(llevError, "Unable to allocate an account_struct!\n");
        fatal(OUT_OF_MEMORY);
    }
    ac->last_login = time(NULL);
    ac->created = ac->last_login;
    ensure_available_characters(ac, 0);
    return ac;
}
 
void accounts_clear(void) {
    accounts.clear();
    accounts_loaded = 0;
}
 
void accounts_load(void) {
    char fname[MAX_BUF], *buf;
    int fields=0;
    BufferReader *br;
 
    if (!accounts.empty()) {
        LOG(llevError, "account_load_entries(): Called when accounts has been set.\n");
        return;
    }
    snprintf(fname, MAX_BUF,"%s/%s", settings.localdir, ACCOUNT_FILE);
    if ((br = bufferreader_init_from_file(NULL, fname, "Unable to open %s [%s]. This may be because this is a new server and no accounts exist yet.\n", llevInfo)) == NULL) {
        return;
    }
 
    while ((buf = bufferreader_next_line(br))) {
        char *tmp[NUM_ACCOUNT_FIELDS], *cp;
        int i;
 
        /* Ignore any comment lines */
        if (buf[0] == '#') continue;
 
        fields = split_string(buf, tmp, NUM_ACCOUNT_FIELDS, ':');
 
        account_struct *ac = account_alloc();
        ac->name = strdup_local(tmp[0]);
        ac->password = strdup_local(tmp[1]);
        ac->last_login = strtoul(tmp[2], (char**)NULL, 10);
 
        /* While probably no one was using this code before this
         * field was added, this provides a nice example of handling
         * additional fields.
         */
        if (fields>4) ac->created = strtoul(tmp[4], (char**)NULL, 10);
        else
            ac->created = ac->last_login;
 
        /* If this is a blank field, nothing to do */
        if (tmp[3][0]) {
            /* count up how many semicolons - this is the character
             * separator.  We start at one, because these are separators,
             * so there will be one more name than separators.
             */
            ac->num_characters=1;
            for (cp = tmp[3]; *cp != '\0'; cp++) {
                if (*cp == ';') ac->num_characters++;
            }
            ensure_available_characters(ac, ac->num_characters);
 
            split_string(tmp[3], ac->character_names, ac->num_characters, ';');
 
            /* The string data that the names are stored in is currently temporary data
             * that will go away, so we need to allocate some permanent data now */
            for (i=0; i<ac->num_characters; i++) {
                ac->character_names[i] = strdup_local(ac->character_names[i]);
            }
        }
 
        accounts.push_back(ac);
    }
 
    bufferreader_destroy(br);
    accounts_loaded = 1;
}
 
static void account_write_entry(FILE *fp, account_struct *ac)
{
    int i;
 
    fprintf(fp,"%s:%s:%u:", ac->name, ac->password, (uint32_t)ac->last_login);
    for (i=0; i<ac->num_characters; i++) {
        if (i != 0)
            fprintf(fp,";%s", ac->character_names[i]);
        else
            fprintf(fp,"%s", ac->character_names[i]);
    }
    fprintf(fp,":%u:\n", (uint32_t) ac->created);
}
 
 
void accounts_save(void)
{
    char fname[MAX_BUF];
    FILE *fp;
    OutputFile of;
 
    if (accounts_loaded == 0)
        return;
 
    snprintf(fname, MAX_BUF,"%s/%s", settings.localdir, ACCOUNT_FILE);
 
    fp = of_open(&of, fname);
    if (fp == NULL)
        return;
 
    fprintf(fp, "# IMPORTANT: Do not edit this file while the server is running. This file is\n"
                "# only read when the server starts, and any changes will be overwritten when\n"
                "# the server exits.\n");
    fprintf(fp, "# Format:\n");
    fprintf(fp, "# Account name:Password:Account last used:Characters (semicolon separated):created:expansion\n");
    for (auto ac : accounts) {
        /* Don't write out accounts with no characters associated unless the
         * account is at least a day old.
         */
        // 86400 seconds in a day, so no reason to make the game have to recalculate this all the time
        // SilverNexus 2014-06-12
        if (ac->num_characters || (ac->created > (time(NULL) - 86400)))
            account_write_entry(fp, ac);
    }
    of_close(&of);
}
 
const char *account_exists(const char *account_name)
{
    for (auto ac : accounts) {
        if (!strcasecmp(ac->name, account_name)) return ac->name;
    }
    return NULL;
}
 
int account_login(const char *account_name, const char *account_password) {
    for (auto ac : accounts) {
        /* Look for a matching account name and check the password. */
        if (!strcasecmp(ac->name, account_name)) {
            if (check_password(account_password, ac->password)) {
                ac->last_login = time(NULL);
                accounts_logged_in.insert(account_name);
                return 1;
            } else {
                return 0;
            }
        }
    }
    return 0;
}
 
void account_logout(const char *account_name) {
    accounts_logged_in.erase(account_name);
}
 
int account_check_string(const char *str)
{
    const char *cp = str;
 
    /* Require first character to be letter or number */
    if (!isalnum(*str)) return 1;
    for (; *str != '\0'; ++str) {
        if (!isprint(*str)) return 1;
        switch (*str){
            case ':':
            case ';':
            case '/':
            case '\'':
            case '[':
                return 1;
        }
    }
    /* Don't allow space characters at end of string. */
    if (isspace(*(str-1))) return 1;
    if ((str - cp) > MAX_NAME) return 2;
    return 0;
}
 
 
int account_new(const char *account_name, const char *account_password) {
    account_struct *ac;
 
    // Check password for invalid characters because newhash() may just
    // return the string in plaintext.
    if (account_check_string(account_name) || account_check_string(account_password))
        return 1;
 
    if (account_exists(account_name)) return 2;
 
    ac = account_alloc();
    ac->name = strdup_local(account_name);
    ac->password = strdup_local(newhash(account_password));
 
    /* We put this at the top of the list.  This means recent accounts will be at
     * the top of the file, which is likely a good thing.
     * We don't do a save right now.  When the player associates a character with
     * the account, we will save them - until that point, not too much reason
     * to save this out.  Note it is still possible for this to get saved out if
     * another player does something that forces writing out of the accounts file.
     */
    accounts.insert(accounts.begin(), ac);
 
    /* mark that accounts should be saved through accounts_save(). */
    accounts_loaded = 1;
 
    return 0;
}
 
int account_link(const char *account_name, const char *player_name) {
    for (auto ac : accounts) {
        if (!strcasecmp(ac->name, account_name)) {
            ensure_available_characters(ac, ac->num_characters + 1);
            ac->character_names[ac->num_characters] = strdup_local(player_name);
            ac->num_characters++;
            return 0;
        }
    }
    return 1;
}
 
int account_remove_player(const char *account_name, const char *player_name) {
    int i, match=0;
 
    if (account_name == NULL)
        return 0;
 
    for (auto ac : accounts) {
        if (!strcasecmp(ac->name, account_name)) {
            /* Try to find the character name.  Once we find it, we set match, and
             * then move the remain character names down by one.  The array is
             * always null terminated, so this also makes sure we copy the null down.
             */
            for (i=0; i<ac->num_characters; i++) {
                if (!strcmp(ac->character_names[i], player_name)) {
                    free(ac->character_names[i]);
                    match=1;
                }
                if (match == 1) {
                    ac->character_names[i] = ac->character_names[i+1];
                }
            }
 
            if (match) {
                ac->num_characters--;
                return 0;
            }
            /* Otherwise, did not find player name */
            return 2;
        }
    }
    return 1;
}
 
 
char **account_get_players_for_account(const char *account_name)
{
    for (auto ac : accounts) {
        if (!strcasecmp(ac->name, account_name)) return ac->character_names;
    }
    return NULL;
}
 
static int char_in_list(const char *name, const std::vector<Account_Char *> chars) {
    for (auto ch : chars) {
        if (strcmp(ch->name, name) == 0) {
            return 1;
        }
    }
    return 0;
}
 
linked_char *account_get_additional_chars(const char *account_name, const Account_Chars *chars, int *count) {
    linked_char *ret = NULL;
 
    for (auto ac : accounts) {
        if (!strcasecmp(ac->name, account_name)) {
            for (int i = 0; i < ac->num_characters; i++) {
                if (!char_in_list(ac->character_names[i], chars->chars)) {
                    linked_char *lc = (linked_char *)calloc(1, sizeof(linked_char));
                    lc->next = ret;
                    lc->name = ac->character_names[i];
                    ret = lc;
                    (*count)++;
                }
            }
            return ret;
        }
    }
    return NULL;
}
 
const char *account_get_account_for_char(const char *charname)
{
    int i;
 
    for (auto ac : accounts) {
        for (i=0; i<ac->num_characters; i++) {
            if (!strcmp(ac->character_names[i], charname)) {
                return ac->name;
            }
        }
    }
    return NULL;
 
}
 
int account_is_logged_in(const char *name) {
    return accounts_logged_in.find(name) != accounts_logged_in.end();
}
 
int account_change_password(const char *account_name,
        const char *current_password, const char *new_password) {
 
    // Check password for invalid characters as in account_new().
    if (account_check_string(account_name) ||
            (current_password != NULL && account_check_string(current_password)) ||
            account_check_string(new_password)) {
        return 1;
    }
 
    // Iterate through accounts list until a matching name is found.
    for (auto ac : accounts) {
        if (!strcasecmp(ac->name, account_name)) {
            // Return an error if the current password does not match.
            if (current_password != NULL && !check_password(current_password, ac->password)) {
                return 3;
            }
 
            free(ac->password);
            ac->password = strdup_local(newhash(new_password));
 
            return 0;
        }
    }
 
    return 2;
}