metaserver.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 "global.h"
 
#include <ctype.h>
#include <pthread.h>
#include <string>
 
#ifndef WIN32 /* ---win32 exclude unix header files */
#include <sys/types.h>
#include <netinet/in.h>
#include <netdb.h>
#include <arpa/inet.h>
 
#endif /* end win32 */
 
#include "metaserver2.h"
#include "version.h"
 
#ifdef HAVE_LIBCURL
#include <curl/curl.h>
#include <curl/easy.h>
#endif
 
static pthread_mutex_t ms2_info_mutex;
 
int count_players() {
    /* We could use socket_info.nconns, but that is not quite as accurate,
     * as connections in the progress of being established, are listening
     * but don't have a player, etc.  The checks below are basically the
     * same as for the who commands with the addition that WIZ, AFK, and BOT
     * players are not counted.
     */
    char num_players = 0;
    for (player *pl = first_player; pl != NULL; pl = pl->next) {
        if (pl->ob->map == NULL)
            continue;
        if (pl->hidden)
            continue;
        if (QUERY_FLAG(pl->ob, FLAG_WIZ))
            continue;
        if (QUERY_FLAG(pl->ob, FLAG_AFK))
            continue;
        if (pl->state != ST_PLAYING && pl->state != ST_GET_PARTY_PASSWORD)
            continue;
        if (pl->socket->is_bot)
            continue;
        num_players++;
    }
    return num_players;
}
 
int count_all_players() {
    int players = 0;
    player *pl;
    for (pl = first_player, players = 0; pl != NULL; pl = pl->next, players++);
    return players;
}
 
void metaserver_update(void) {
#ifdef HAVE_LIBCURL
    /* Everything inside the pthread lock/unlock is related
     * to metaserver2 synchronization.
     */
    pthread_mutex_lock(&ms2_info_mutex);
    metaserver2_updateinfo.num_players = count_players();
    metaserver2_updateinfo.in_bytes = cst_tot.ibytes;
    metaserver2_updateinfo.out_bytes = cst_tot.obytes;
    metaserver2_updateinfo.uptime  = (long)time(NULL)-cst_tot.time_start;
    pthread_mutex_unlock(&ms2_info_mutex);
#endif
}
 
/*
 * Start of metaserver2 logic
 * Note: All static structures in this file should be treated as strictly
 * private.  The metaserver2 update logic runs in its own thread,
 * so if something needs to modify these structures, proper locking
 * is needed.
 */
 
static std::vector<std::string> metaservers;
 
struct LocalMeta2Info {
    int     notification;  
    char    *hostname;     
    int     portnumber;    
    char    *html_comment; 
    char    *text_comment; 
    char    *archbase;     
    char    *mapbase;      
    char    *codebase;
    char    *flags;        
};
 
static LocalMeta2Info local_info;
 
MetaServer2_UpdateInfo metaserver2_updateinfo;
 
int metaserver2_init(void) {
    static int has_init = 0;
    FILE *fp;
    char buf[MAX_BUF], *cp, dummy[1];
    pthread_t thread_id;
 
    dummy[0] = '\0';
 
#ifdef HAVE_LIBCURL
    if (!has_init) {
        memset(&local_info, 0, sizeof(LocalMeta2Info));
        memset(&metaserver2_updateinfo, 0, sizeof(MetaServer2_UpdateInfo));
 
        local_info.portnumber = settings.csport;
        pthread_mutex_init(&ms2_info_mutex, NULL);
        curl_global_init(CURL_GLOBAL_ALL);
    } else {
        local_info.notification = 0;
        if (local_info.hostname)
            FREE_AND_CLEAR(local_info.hostname);
        if (local_info.html_comment)
            FREE_AND_CLEAR(local_info.html_comment);
        if (local_info.text_comment)
            FREE_AND_CLEAR(local_info.text_comment);
        if (local_info.archbase)
            FREE_AND_CLEAR(local_info.archbase);
        if (local_info.mapbase)
            FREE_AND_CLEAR(local_info.mapbase);
        if (local_info.codebase)
            FREE_AND_CLEAR(local_info.codebase);
        if (local_info.flags)
            FREE_AND_CLEAR(local_info.flags);
        metaservers.clear();
    }
#endif
 
    /* Now load up the values from the file */
    snprintf(buf, sizeof(buf), "%s/metaserver2", settings.confdir);
 
    if ((fp = fopen(buf, "r")) == NULL) {
        LOG(llevError, "Warning: No metaserver2 file found\n");
        return 0;
    }
    while (fgets(buf, sizeof(buf), fp) != NULL) {
        if (buf[0] == '#')
            continue;
        /* eliminate newline */
        if ((cp = strrchr(buf, '\n')) != NULL)
            *cp = '\0';
 
        /* Skip over empty lines */
        if (buf[0] == 0)
            continue;
 
        /* Find variable pairs */
 
        if ((cp = strpbrk(buf, " \t")) != NULL) {
            while (isspace(*cp))
                *cp++ = 0;
        } else {
            /* This makes it so we don't have to do NULL checks against
             * cp everyplace
             */
            cp = dummy;
        }
 
        if (!strcasecmp(buf, "metaserver2_notification")) {
            if (!strcasecmp(cp, "on") || !strcasecmp(cp, "true")) {
                local_info.notification = TRUE;
            } else if (!strcasecmp(cp, "off") || !strcasecmp(cp, "false")) {
                local_info.notification = FALSE;
            } else {
                LOG(llevError, "metaserver2: Unknown value for metaserver2_notification: %s\n", cp);
            }
        } else if (!strcasecmp(buf, "metaserver2_server")) {
            if (*cp != 0) {
                metaservers.push_back(cp);
            } else {
                LOG(llevError, "metaserver2: metaserver2_server must have a value.\n");
            }
        } else if (!strcasecmp(buf, "localhostname")) {
            if (*cp != 0) {
                local_info.hostname = strdup_local(cp);
            } else {
                LOG(llevError, "metaserver2: localhostname must have a value.\n");
            }
        } else if (!strcasecmp(buf, "portnumber")) {
            if (*cp != 0) {
                local_info.portnumber = atoi(cp);
            } else {
                LOG(llevError, "metaserver2: portnumber must have a value.\n");
            }
        /* For the following values, it is easier to make sure
         * the pointers are set to something, even if it is a blank
         * string, so don't care if there is data in the string or not.
         */
        } else if (!strcasecmp(buf, "html_comment")) {
            local_info.html_comment = strdup(cp);
        } else if (!strcasecmp(buf, "text_comment")) {
            local_info.text_comment = strdup(cp);
        } else if (!strcasecmp(buf, "archbase")) {
            local_info.archbase = strdup(cp);
        } else if (!strcasecmp(buf, "mapbase")) {
            local_info.mapbase = strdup(cp);
        } else if (!strcasecmp(buf, "codebase")) {
            local_info.codebase = strdup(cp);
        } else if (!strcasecmp(buf, "flags")) {
            local_info.flags = strdup(cp);
        } else {
            LOG(llevError, "Unknown value in metaserver2 file: %s\n", buf);
        }
    }
    fclose(fp);
 
    /* If no hostname is set, can't do updates */
    if (!local_info.hostname)
        local_info.notification = 0;
 
#ifndef HAVE_LIBCURL
    if (local_info.notification) {
        LOG(llevError, "metaserver2 file is set to do notification, but libcurl is not found.\n");
        LOG(llevError, "Either fix your compilation, or turn off metaserver2 notification in \n");
        LOG(llevError, "the %s/metaserver2 file.\n", settings.confdir);
        LOG(llevError, "Exiting program.\n");
        exit(1);
    }
#endif
 
    if (local_info.notification) {
        int ret;
 
        /* As noted above, it is much easier for the rest of the code
         * to not have to check for null pointers.  So we do that
         * here, and anything that is null, we just allocate
         * an empty string.
        */
        if (!local_info.html_comment)
            local_info.html_comment = strdup("");
        if (!local_info.text_comment)
            local_info.text_comment = strdup("");
        if (!local_info.archbase)
            local_info.archbase = strdup("");
        if (!local_info.mapbase)
            local_info.mapbase = strdup("");
        if (!local_info.codebase)
            local_info.codebase = strdup("");
        if (!local_info.flags)
            local_info.flags = strdup("");
 
        ret = pthread_create(&thread_id, NULL, metaserver2_thread, NULL);
        if (ret) {
            LOG(llevError, "metaserver2_init: return code from pthread_create() is %d\n", ret);
 
            /* Effectively true - we're not going to update the metaserver */
            local_info.notification = 0;
        }
    }
    return local_info.notification;
}
 
static size_t metaserver2_writer(void *ptr, size_t size, size_t nmemb, void *data) {
    (void)data;
    size_t realsize = size*nmemb;
    LOG(llevError, "Message from metaserver:\n%s\n", (const char*)ptr);
    return realsize;
}
 
#ifdef HAVE_LIBCURL
static void metaserver2_build_form(struct curl_httppost **formpost) {
    struct curl_httppost *lastptr = NULL;
    char buf[MAX_BUF];
 
    /* First, fill in the form - note that everything has to be a string,
     * so we convert as needed with snprintf.
     * The order of fields here really isn't important.
     * The string after CURLFORM_COPYNAME is the name of the POST variable
     * as the
     */
    curl_formadd(formpost, &lastptr,
                 CURLFORM_COPYNAME, "hostname",
                 CURLFORM_COPYCONTENTS, local_info.hostname,
                 CURLFORM_END);
 
    snprintf(buf, sizeof(buf), "%d", local_info.portnumber);
    curl_formadd(formpost, &lastptr,
                 CURLFORM_COPYNAME, "port",
                 CURLFORM_COPYCONTENTS, buf,
                 CURLFORM_END);
 
    curl_formadd(formpost, &lastptr,
                 CURLFORM_COPYNAME, "html_comment",
                 CURLFORM_COPYCONTENTS, local_info.html_comment,
                 CURLFORM_END);
 
    curl_formadd(formpost, &lastptr,
                 CURLFORM_COPYNAME, "text_comment",
                 CURLFORM_COPYCONTENTS, local_info.text_comment,
                 CURLFORM_END);
 
    curl_formadd(formpost, &lastptr,
                 CURLFORM_COPYNAME, "archbase",
                 CURLFORM_COPYCONTENTS, local_info.archbase,
                 CURLFORM_END);
 
    curl_formadd(formpost, &lastptr,
                 CURLFORM_COPYNAME, "mapbase",
                 CURLFORM_COPYCONTENTS, local_info.mapbase,
                 CURLFORM_END);
 
    curl_formadd(formpost, &lastptr,
                 CURLFORM_COPYNAME, "codebase",
                 CURLFORM_COPYCONTENTS, local_info.codebase,
                 CURLFORM_END);
 
    curl_formadd(formpost, &lastptr,
                 CURLFORM_COPYNAME, "flags",
                 CURLFORM_COPYCONTENTS, local_info.flags,
                 CURLFORM_END);
 
    pthread_mutex_lock(&ms2_info_mutex);
 
    snprintf(buf, sizeof(buf), "%d", metaserver2_updateinfo.num_players);
    curl_formadd(formpost, &lastptr,
                 CURLFORM_COPYNAME, "num_players",
                 CURLFORM_COPYCONTENTS, buf,
                 CURLFORM_END);
 
    snprintf(buf, sizeof(buf), "%d", metaserver2_updateinfo.in_bytes);
    curl_formadd(formpost, &lastptr,
                 CURLFORM_COPYNAME, "in_bytes",
                 CURLFORM_COPYCONTENTS, buf,
                 CURLFORM_END);
 
    snprintf(buf, sizeof(buf), "%d", metaserver2_updateinfo.out_bytes);
    curl_formadd(formpost, &lastptr,
                 CURLFORM_COPYNAME, "out_bytes",
                 CURLFORM_COPYCONTENTS, buf,
                 CURLFORM_END);
 
    snprintf(buf, sizeof(buf), "%ld", (long)metaserver2_updateinfo.uptime);
    curl_formadd(formpost, &lastptr,
                 CURLFORM_COPYNAME, "uptime",
                 CURLFORM_COPYCONTENTS, buf,
                 CURLFORM_END);
 
    pthread_mutex_unlock(&ms2_info_mutex);
 
    /* Following few fields are global variables,
     * but are really defines, so won't ever change.
     */
    curl_formadd(formpost, &lastptr,
                 CURLFORM_COPYNAME, "version",
                 CURLFORM_COPYCONTENTS, FULL_VERSION,
                 CURLFORM_END);
 
    snprintf(buf, sizeof(buf), "%d", VERSION_SC);
    curl_formadd(formpost, &lastptr,
                 CURLFORM_COPYNAME, "sc_version",
                 CURLFORM_COPYCONTENTS, buf,
                 CURLFORM_END);
 
    snprintf(buf, sizeof(buf), "%d", VERSION_CS);
    curl_formadd(formpost, &lastptr,
                 CURLFORM_COPYNAME, "cs_version",
                 CURLFORM_COPYCONTENTS, buf,
                 CURLFORM_END);
}
#endif
 
static void metaserver2_updates(void) {
#ifdef HAVE_LIBCURL
    struct curl_httppost *formpost = NULL;
    metaserver2_build_form(&formpost);
 
    for (auto hostname : metaservers) {
        CURL *curl = curl_easy_init();
        if (curl) {
            /* what URL that receives this POST */
            curl_easy_setopt(curl, CURLOPT_URL, hostname.c_str());
            curl_easy_setopt(curl, CURLOPT_HTTPPOST, formpost);
 
            /* Almost always, we will get HTTP data returned
             * to us - instead of it going to stderr,
             * we want to take care of it ourselves.
             */
            curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, metaserver2_writer);
 
            char errbuf[CURL_ERROR_SIZE];
            curl_easy_setopt(curl, CURLOPT_ERRORBUFFER, errbuf);
 
            CURLcode res = curl_easy_perform(curl);
            if (res) {
                LOG(llevError, "metaserver update failed: %s\n", errbuf);
            }
 
            /* always cleanup */
            curl_easy_cleanup(curl);
        } else {
            LOG(llevError, "metaserver: could not initialize curl\n");
        }
    }
    /* then cleanup the formpost chain */
    curl_formfree(formpost);
#endif
}
 
void *metaserver2_thread(void *junk) {
    (void)junk;
    while (1) {
        metaserver2_updates();
        sleep(60);
    }
    return NULL;
}