source: chevmsgr/trunk/msg.hpp@ 31

#pragma once

#include "cf/logger.h"
#include "cf/network.h"

#include "json.h"
#include "crypto.h"

#include <iostream>
#include <string>
#include <vector>
#include <time.h>

typedef struct SFriend
{
    std::string id;
    std::string name;
} SFriend;

#define DELIMITER   "$"

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

namespace ProtocolType
{
#define DECLARE_KEY(_t) static const std::string _t = #_t

    DECLARE_KEY(NONE);
    DECLARE_KEY(SECRET);
    DECLARE_KEY(RANDOM);
    DECLARE_KEY(ID);
    DECLARE_KEY(TYPE);
    DECLARE_KEY(NAME);
    DECLARE_KEY(SMS);
    DECLARE_KEY(PHONE);
    DECLARE_KEY(JOIN);
    DECLARE_KEY(PW);
    DECLARE_KEY(LOGIN);
    DECLARE_KEY(LOGOUT);
    DECLARE_KEY(ADD_FRIEND);
    DECLARE_KEY(OPEN_SESSION);
    DECLARE_KEY(TO);
    DECLARE_KEY(LISTEN);
    DECLARE_KEY(TELL);
    DECLARE_KEY(FROM);
    DECLARE_KEY(SESSION_ID);
    DECLARE_KEY(SESSION_KEY);
    DECLARE_KEY(MESSAGE);
    DECLARE_KEY(SENSITIVE);
    DECLARE_KEY(GET_FRIEND_LIST);
    DECLARE_KEY(FRIEND_LIST);
    DECLARE_KEY(FRIEND_ID);
    DECLARE_KEY(ID_LIST);
    DECLARE_KEY(RESULT);
}

namespace Protocol
{
    class Message
    {
    public:
        json::Object mObject;

        Message();

        void parse(const std::string & message);

        template<typename T>
        T get(const std::string & key) const
        {
            return (T)mObject[key];
        }

        template<typename T>
        std::vector<T> getList(const std::string & key) const
        {
            std::vector<T> ret;
            json::Array ar = mObject[key];

            for (size_t iter = 0; iter < ar.size(); iter++)
                ret.push_back(ar[iter]);

            return ret;
        }

        std::vector<SFriend> getFriendList() const;

        std::string type() const;

        std::string serialize() const;
    };

    class IProtocol
    {
    public:
        virtual void makeTemplate(json::Object & obj, const std::string & type) const = 0;
    };

    class Request : public IProtocol
    {
    private:
        std::string mID;

    public:
        void setUserID(const std::string & id);

        const std::string & getUserID();

        void makeTemplate(json::Object & obj, const std::string & type) const;

        std::string sms(const std::string & phone) const;

        std::string join(const std::string & id, const std::string & pw, const std::string & sms) const;

        std::string login(const std::string & pw) const;

        std::string secretWithRandom(const std::string & type, const std::string & id, std::string & secret, const std::string & random) const;

        std::string logout() const;

        std::string addFriend(const std::string & id) const;

        std::string openSession(const std::vector<std::string> & idList) const;

        std::string tell(const std::string & sessid, const std::string & message, const bool sensitive) const;

        std::string getFriendList() const;
    };

    class Response : public IProtocol
    {
    public:
        void makeTemplate(json::Object & obj, const std::string & type) const;

        std::string result(const std::string & requestType, const bool status) const;

        std::string friendList(const std::vector<SFriend> & friendList) const;
    };
};

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

#define LOG(message)    log(__FILE__,__func__,__LINE__,message)

static void log(const std::string & file,
                const std::string & func,
                const int line,
                const std::string & message)
{
    static cf::logger * logger = NULL;

    if (!logger)
    {
        logger = cf::logger::getInstance();
        logger->init(".");
        logger->setLevel(1);
        logger->add("messenger", 1, "INFO", 0);
    }

    logger->write(1, message);
    std::cerr << "[" << file << ":" << line << "][" << func << "] "
              << message << std::endl;
}

static std::string joinStrings(const std::vector<std::string> & strings)
{
    std::string concat = strings[0];

    for (size_t iter = 1; iter < strings.size(); iter++)
        concat += "," + strings[iter];

    return concat;
}

static cf::bin generateRandom()
{
    int t = (int)time(NULL);

    cf::bin b;
    b.resize(sizeof(int));

    b.set((cf::uint8_t*)&t, sizeof(int));
    return crypto().sha256(b);
}

class SecureSocket
{
private:
    cf::network::tcp * sock;
    crypto aria;

public:
    SecureSocket()
    {
        sock = NULL;
    }

    SecureSocket(cf::network::tcp * sock, const std::string & ip, const std::string & sms)
    {
        setSocket(sock);
        setKey(ip, sms);
    }

    void setSocket(cf::network::tcp * sock)
    {
        this->sock = sock;
    }

    cf::network::tcp & getTcpSocket()
    {
        return *sock;
    }

    void setKey(const std::string & ip, const std::string & sms)
    {
        cf::bin seed = sms + DELIMITER + ip;
        cf::bin key = crypto().sha256(seed);

        aria.setKey(key);
    }

    void send(const std::string & msg)
    {
        sock->send(aria.encrypt(cf::bin(msg)));
    }
    
    std::string receive()
    {
        return aria.decrypt(sock->receive()).toString();
    }

    void close()
    {
        if (sock)
            sock->close();
    }
};