source: chevmsgr/trunk/msgsrv.cpp@ 13

#include "cf/network.h"
#include "cf/task.h"
#include "cf/codec.h"
#include "cf/file.h"
#include "crypto.h"

#include "msg.hpp"

#include <map>
#include <stdlib.h>
#include <time.h>

#include "sqlite3.h"

// --------------------------------------------------------------

typedef struct
{
    cf::network::tcp * sock;
    cf::bin key;
} LoginSession;
std::map<std::string, LoginSession> gOnlineUsers;


//================================================================

int cb_getFriendList(void * userArg, int argc, char ** argv, char ** colName)
{
    std::string * friendList = (std::string *) userArg;

    *friendList = argv[1];

    return 0;
}

int cb_getSMS(void * userArg, int argc, char ** argv, char ** colName)
{
    std::string * SMS = (std::string *) userArg;

    *SMS = argv[1];

    return 0;
}

int cb_login(void * userArg, int argc, char ** argv, char ** colName)
{
    bool * result = (bool *)userArg;

    *result = true;

    return 0;
}

int cb_join(void * userArg, int argc, char ** argv, char ** colName)
{
    bool * isExist = (bool *)userArg;

    *isExist = true;

    return 0;
}

//===============================================================

// --------------------------------------------------------------
class DBManager
{
private:
    sqlite3 * db;

public:
    DBManager()
        throw (cf::exception)
        : db(NULL)
    {
    }
    
    void Init()
        throw (cf::exception)
    {
        int result = 0;
        bool isExist = false;
        
        isExist = cf::file("account.db").exists();

        result = sqlite3_open("account.db", &db);
        if (result)
            fprintf(stderr, "sqlite_open failed\n");
        
        if (!isExist)
            setup();
    }

    void setup()
        throw (cf::exception)
    {
        std::string sqlCreateAccountTable;
        std::string sqlCreateAuthTable;
        std::string sqlCreateFriendsTable;
        // declaration

        // query
        sqlCreateAccountTable =
            "CREATE TABLE T_ACCOUNT"
            "("
            "   no  INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,"
            "   id  TEXT,"
            "   pw  TEXT"
            ")";
        sqlCreateAuthTable =
            "CREATE TABLE T_AUTH"
            "("
            "   id      TEXT PRIMARY KEY NOT NULL,"
            "   sms1    TEXT,"
            "   ip1     TEXT,"
            "   sms2    TEXT,"
            "   ip2     TEXT,"
            "   sms3    TEXT,"
            "   ip3     TEXT,"
            "   sms4    TEXT,"
            "   ip4     TEXT,"
            "   sms5    TEXT,"
            "   ip5     TEXT"
            ")";
        sqlCreateFriendsTable =
            "CREATE TABLE T_FRIENDS"
            "("
            "   id      TEXT PRIMARY KEY NOT NULL,"
            "   friend  TEXT"
            ")";

        exec(sqlCreateAccountTable, NULL, NULL);
        exec(sqlCreateAuthTable, NULL, NULL);
        exec(sqlCreateFriendsTable, NULL, NULL);
    }
    
    void exec(std::string & query, sqlite3_callback cb, void * userArg)
        throw(cf::exception)
    {
        int result;
        char * errMsg;

        result = sqlite3_exec(db, query.c_str(), cb, userArg, &errMsg);

        if (result != SQLITE_OK)
            THROW_EXCEPTION (errMsg);
    }

    bool login(const std::string & id, const std::string & pw)
        throw (cf::exception)
    {       
        try
        {
            bool result = false;
            std::string query = "select * from T_ACCOUNT where id ='" + id + "' and pw = '" + pw + "'";

            this->exec(query, cb_login, &result);

            return result;
        }
        catch (cf::exception & e)
        {
            FORWARD_EXCEPTION(e);

            return false;
        }
    }

    bool join(const std::string & id, const std::string & pw, const std::string & sms, const std::string & ip)
        throw (cf::exception)
    {
        try
        {
            bool isExist = false;
            std::string existQuery = "select * from T_ACCOUNT where id = '" + id + "'";
            std::string insertQuery = "insert into T_ACCOUNT values('" + id + "', '" + pw + "', '" + sms + "', '" + ip + "')";

            this->exec(existQuery, cb_join, &isExist);

            if (!isExist)
                this->exec(insertQuery, NULL, NULL);
        }
        catch (cf::exception & e)
        {
            FORWARD_EXCEPTION(e);
        }

        return true;
    }

    std::string getFriendList(std::string & id)
        throw(cf::exception)
    {
        int result = 0;
        std::string friendList;

        try
        {
            std::string query = "select * from T_FRIENDS where id = '" + id + "'";

            this->exec(query, cb_getFriendList, &friendList);
        }
        catch (cf::exception & e)
        {
            FORWARD_EXCEPTION(e);
        }   
    }

    int getSMS(std::string & id)
    {
        int result = 0;
        std::string smsMsg;

        try
        {
            std::string query = "select * from T_AUTH where id = '" + id + "'";

            this->exec(query, cb_getSMS, &smsMsg);
        }
        catch (cf::exception & e)
        {
            FORWARD_EXCEPTION(e);
        }
    }

    int addFriend(std::string & id)
    {
        try
        {
            std::string query = "insert into T_FRIENDS values('" + id + "')";

            this->exec(query, NULL, NULL);
        }
        catch (cf::exception & e)
        {
            FORWARD_EXCEPTION(e);
        }
    }
};
DBManager dbmgr;

class Runner
{
public:
    cf::network::tcp * mSock;
    cf::task::thread * mThread;

    Runner(cf::network::tcp & sock, int (*worker)(void *))
        : mSock(NULL)
        , mThread(NULL)
    {
        mSock = new(std::nothrow) cf::network::tcp(sock.detach());
        mThread = new(std::nothrow) cf::task::thread(worker);
        if (!mSock || !mThread)
        {
            dispose();
            THROW_EXCEPTION("cannot allocate thread arguments");
        }

        mThread->start(this);
    }

    ~Runner()
    {
        dispose();
    }

    void dispose()
    {
        if (mSock) delete mSock;
        if (mThread) delete mThread;
    }
};

static bool isOnline(const std::string & id)
{
    return gOnlineUsers.find(id) != gOnlineUsers.end();
}

static void logout(const std::string & id)
{
    gOnlineUsers.erase(id);
}

static std::string getRandomCode()
{
    char random[8] = {0x00,};
    sprintf(random, "%06d", rand() % 1000000);

    return random;
}

static std::string httpSMS(const Protocol::Message & parser)
{
    std::string phone = parser.get<std::string>("phone");

#define CRLF    "\r\n"
    std::string code = getRandomCode();
    std::string url = "unsigned.kr";
    std::string uri = "/~cheese/sms/req.php?to=" + phone + "&code=" + code;
    std::string http =
        "GET " + uri + " HTTP/1.1" CRLF
        "Host: " + url + CRLF
        "Accept: text/plain" CRLF
        CRLF;

    Protocol::Response response;
    cf::network::tcp smsSock;
    cf::network::host smsServer(url, 80);

    smsSock.connect(smsServer);
    smsSock.send(http);
    smsSock.close();

    return code;
}

static bool join(const Protocol::Message & parser, const std::string & sms, const std::string & address)
    throw (cf::exception)
{
    if (sms != parser.get<std::string>(ProtocolType::SMS))
        THROW_EXCEPTION("SMS is not same");

    std::string id = parser.get<std::string>(ProtocolType::ID);
    std::string pw = parser.get<std::string>(ProtocolType::PW);
        
    return dbmgr.join(id, pw, sms, address);
}

static bool login(const Protocol::Message & parser)
    throw (cf::exception)
{
    std::string id = parser.get<std::string>(ProtocolType::ID);
    std::string pw = parser.get<std::string>(ProtocolType::PW);

    return dbmgr.login(id, pw);
}

static bool chat(const Protocol::Message & parser,
                 const std::string & message)
{
    bool result = false;
    std::string to = parser.get<std::string>(ProtocolType::TO);

    if (isOnline(to))
    {
        gOnlineUsers[to].sock->send(message);
        result = true;
    }

    return result;
}

static std::string createSessionID(std::string & idList)
{
    cf::bin sessid;

    sessid = crypto().sha256(cf::bin(idList));

    return cf::codec::hex::getInstance()->encode(sessid);
}

static bool opensession(const Protocol::Message & parser)
{
    bool result = false;
    std::string sessid;
    std::vector<std::string> idList = parser.getList<std::string>(ProtocolType::ID_LIST);
    std::string concat = idList[0];

    for (size_t iter = 1; iter < concat.size(); iter++)
        concat += idList[iter]; 

    sessid = createSessionID(concat);

    for (size_t iter = 0; iter < idList.size(); iter++)
    {
        if (isOnline(idList[iter]))
            gOnlineUsers[idList[iter]].sock->send(sessid);

        result = true;
    }

    return result;
}

static std::string keyExchange(const std::string sms, const std::string address)
{
    cf::bin sessKey;

    sessKey = crypto().sha256(cf::bin(sms + address));

    return cf::codec::hex::getInstance()->encode(sessKey);
}

static std::string workerInitiator(cf::network::tcp & sock)
{
    try
    {
        std::string sms;

        while (true)
        {
            Protocol::Message parser;
            parser.parse(sock.receive().toString());

            if (parser.type() == "sms")
            {
                sms = httpSMS(parser);
            }
            else if (parser.type() == "join")
            {
                if (join(parser, sms, sock.peer().address()))
                    THROW_EXCEPTION("user(" << parser.get<std::string>(ProtocolType::ID) << ") cannot join");
            }
            else if (parser.type() == "login")
            {
                if (login(parser))
                    parser.get<std::string>(ProtocolType::ID);
            }           
        }
    }
    catch (cf::exception & e)
    {
        FORWARD_EXCEPTION(e);
    }
}

static int worker(void * arg)
{
    Runner * runner = reinterpret_cast<Runner *>(arg);
    cf::network::tcp * sock  = runner->mSock;

    std::string id;

    try
    {
        workerInitiator(*sock);

        Protocol::Response response;
        bool result = true;

        while (result)
        {
            std::string message = sock->receive().toString();
            Protocol::Message parser;
            parser.parse(message);

            LOG(message);

            if (parser.type() == "chat")
                result = chat(parser, message);
            else if (parser.type() == "opensession")
                result = opensession(parser);
//          else if (parser.type() == "getFriendList")
//              result = 

            sock->send(response.result(parser.type(), result));
        }
    }
    catch (cf::exception & e)
    {
        LOG(e.what());
    }

    logout(id);
    delete runner;
    return 0;
}

static int server(unsigned short port)
{
    cf::network::tcp sock;

    srand((unsigned int)time(NULL));

    try
    {
        sock.bind(port);
        sock.listen();
    }
    catch(cf::exception & e)
    {
        LOG(e.what());
        return -1;
    }

    while (true)
    {
        try
        {
            cf::network::tcp client = sock.accept();
            Runner * runner = new(std::nothrow) Runner(client, worker);
            if (!runner)
                THROW_EXCEPTION("cannot create thread argument");
        }
        catch(cf::exception & e)
        {
            LOG(e.what());
        }
    }

    return 0;
}

int main(int argc, char ** argv)
{
    if (argc != 2)
    {
        std::cerr << "-_-^" << std::endl;
        return -1;
    }

    return server((unsigned short)atoi(argv[1]));
}