source: trollforge/lastmeasure/server/lmutil.h @ 673

#include <string>
#include <sstream>
#include <iostream>

#include <cstring>
#include <cstdlib>

#include <unistd.h> /* setregid() */
#include <signal.h> /* raise() */
#include <time.h> /* localtime_r() */

#include "md5.h"
#include "lmkeywords.h"

class Random
{
public:
    static std::string ServerName()
    {
        static char const *server[] =
        {
            "Apache",
            "Apache/1.3.33 (Unix) mod_gzip/1.3.26.1a mod_ssl/2.8.23 OpenSSL/0.9.7e",
            "Apache/1.3.42 (Unix) mod_perl/1.31",
            "Apache/1.3.42 (Unix) PHP/5.3.8 with Suhosin-Patch",
            "Apache/2.0.52 (Red Hat)",
            "Apache/2.0.54 (Fedora)",
            "Apache/2.2.9",
            "Apache/2.2.10 (Unix) PHP/5.2.6",
            "Apache/2.2.16 (Debian)",
            "Apache/2.2.20 (Unix) mod_ssl/2.2.20 OpenSSL/0.9.8e-fips-rhel5 PHP/5.2.5",
            "Apache/2.2.20 (Unix) PHP/5.2.17",
            "Apache/2.2.21 (Unix) PHP/5.2.17",
            "Apache/2.2.3 (CentOS)",
            "Apache/2.2.3 (Oracle)",
            "Apache-Coyote/1.1",
            "lighttpd/1.4.28",
            "lighttpd/1.4.30",
            "Microsoft-IIS/6.0",
            "Microsoft-IIS/7.5",
            "nginx",
            "nginx/0.7.64",
            "nginx/0.8.32",
            "nginx/0.8.54",
            "nginx/1.0.11",
            "nginx/1.1.8",
            "PWS/1.7.3.7",
            "squid/2.7.STABLE9",
            "squid/3.1.10",
        };

        return server[rand() % (sizeof(server) / sizeof(*server))];
    }

    static std::string Title()
    {
        std::stringstream ret("");

        ret << titles[rand() % (sizeof(titles) / sizeof(*titles))];

        return ret.str();
    }

    static std::string Keywords(size_t count)
    {
        std::stringstream ret("");

        for (size_t i = 0; i < count; i++)
        {
            if (i)
                ret << ", ";
            ret << keywords[rand() % (sizeof(keywords) / sizeof(*keywords))];
        }

        return ret.str();
    }
};

class Utils
{
public:
    static void Chroot()
    {
        /* FIXME: the return value is ignored; we can't chroot if we
         * weren't launched setuid, but that's not too bad */
        chroot(".");
    }

    static void DropPrivileges()
    {
        setregid(getgid(), getgid());
        setreuid(getuid(), getuid());
    }

    static std::string Time()
    {
        char now[128];
        struct tm tm;
        time_t t = time(NULL);
        strftime(now, 128, "%a, %d %b %Y %T %z", localtime_r(&t, &tm));
        return now;
    }

    static void OhShitShitShit(char const *message)
    {
        /* We don't need to try to recover and be exploited through some
         * shitty vuln I may have forgotten, so just fucking die already */
        std::cerr << "fatal: " << message << std::endl;
        raise(SIGTERM);
    }
/**
 * FIXME: I'm not even sure if these functions work right.
 * (Or at all... It's very likely that they don't do anything right.)
 * I stuck the original PHP code in a comment above each function for reference.
 *  -- Leon
 */

    /**
     * Generate a unique key from the current time and an IP address. It starts
     * with -time() so that newest hits are stored first in alphabetical order.
     */
//return sprintf('%08x', 0xffffffff - time()) . substr(md5($ip . rand()), 0, 8);
    static std::string GenKey(char const *client_ip)
    {
        time_t t = time(NULL);
        srand(t);

        char buffer[16];
        char iphash[37];
        char hash[8];

        sprintf(iphash,"%s%d",client_ip,rand()%32767);

        md5((unsigned char*)iphash,8,(unsigned char*)hash);

        sprintf(buffer, "%lx", (0xffffffff - t));
        strcat(buffer,hash);

        return buffer;
    }

    /* Get back the date value from a key */
//return 0xffffffff - hexdec(substr($key, 0, 8));
    static std::string KeyToDate(char const *key)
    {
        char buffer[8];
        char prekey[8];

        strncpy(prekey,key,8);
        int hexkey = atoi(prekey);
        sprintf(buffer, "%c", 0xffffffff - hexkey);

        return buffer;
    }

    static char * ParseQuery(char toparse[])
    {
        char * pch = strtok(toparse, "&");

        while (pch != NULL)
        {
            printf("%s\n",pch);
            pch = strtok(NULL, "&");
        }
        return pch; // TODO return an array/list of somesort.
    }

};

template<int CAPACITY> class Queue
{
public:
    Queue()
    {
        m_start = m_count = 0;
        m_poppers = m_pushers = 0; // i like poppers -- Leon
        pthread_mutex_init(&m_mutex, NULL);
        pthread_cond_init(&m_empty_cond, NULL);
        pthread_cond_init(&m_full_cond, NULL);
    }

    ~Queue()
    {
        pthread_cond_destroy(&m_empty_cond);
        pthread_cond_destroy(&m_full_cond);
        pthread_mutex_destroy(&m_mutex);
    }

    void Push(int value)
    {
        pthread_mutex_lock(&m_mutex);
        m_pushers++;

        while (m_count == CAPACITY)
            pthread_cond_wait(&m_full_cond, &m_mutex);

        m_pushers--;
        m_values[(m_start + m_count) % CAPACITY] = value;
        m_count++;

        if (m_poppers)
            pthread_cond_signal(&m_empty_cond);

        pthread_mutex_unlock(&m_mutex);
    }

    int Pop()
    {
        pthread_mutex_lock(&m_mutex);
        m_poppers++;

        while (m_count == 0)
            pthread_cond_wait(&m_empty_cond, &m_mutex);

        m_poppers--;
        int ret = m_values[m_start];
        m_start = (m_start + 1) % CAPACITY;
        m_count--;

        if (m_pushers)
            pthread_cond_signal(&m_full_cond);

        pthread_mutex_unlock(&m_mutex);
        return ret;
    }

private:
    int m_values[CAPACITY];
    size_t m_start, m_count;
    size_t m_poppers, m_pushers;
    pthread_mutex_t m_mutex;
    pthread_cond_t m_empty_cond, m_full_cond;
};