ClientPP.h

Go to the documentation of this file.

 
 
#ifndef _CLIENT_H
#define _CLIENT_H
 
#include <NSC.h>
#include "GroupManager.h"
#include "Serializer.h"
#include <string>
#include <KISS.h>
#include <memory>
#include <vector>
#include <iostream>
#include <sstream>

 
enum class ClientType {
    LOCAL, 
    REMOTE 
};
 
class ClientPP;

typedef struct ClientData {
    EventType type;
    ConnType connType;
    IP_Type ipType;
    SOCKET socket;
    SIN addr;
    std::shared_ptr<ClientPP> client;
    std::vector<std::string> data;
} ClientData;

template <typename T>
auto createDataCallback(T* ptr, void (T::* method)(std::vector<std::string>)) {
    return [ptr, method](std::vector<std::string> v) {
        (ptr->*method)(v);
        };
}

template <typename T>
auto createDisconnectionCallback(T* ptr, void (T::* method)()) {
    return [ptr, method]() {
        (ptr->*method)();
        };
}

void sendUDP(SOCKET* serverSocket, SIN* addr, IP_Type ipType, std::string message);

std::string domainNameResolution(std::string domainName);
 
class ClientPP {
public:
    ClientPP(Client clientInfo);

    ClientPP(const std::string& address, int port, const std::string& separator, IP_Type ipType = IP_Type::IPv4, bool useCiphering = true);

    ~ClientPP();
    
    void send(const std::string& data, ConnType connType = ConnType::TCP);
    
    const std::string& getID();

    void kick();

    const Client& getClientStruct();

    void start();

    void addDataCallback(const std::string& key, std::function<void(std::vector<std::string>)> callback);

    void addDisconnectionCallback(std::function<void(void)> callback);

    bool getHaveSecret();

    void stop();

    void setSharedSecret(const std::string& PK);

    std::string decrypt(const std::string& cipher);

    void setKeysPaths(const std::string& PKFile, const std::string& SKFile);

    void setServerPKPath(const std::string& SPKFile);
 
protected: 
    std::shared_ptr<SymmetricCipherInterface> symmetricCipher;

    std::unique_ptr<KeyExchangeInterface> kxInterface;
     
    Client* clientTCP;

    Client* clientUDP;

    ClientType type;

    std::string ID;

    bool isDisconnected;

    std::stop_source stopTag;

    void run(std::stop_token st);

    void init();

    bool haveSecret;

    bool useCiphering;

    std::jthread runThread;
    
    std::string address;
    int port;
    IP_Type ipType;

    std::unordered_map<std::string, std::function<void(std::vector<std::string>)>> dataRcvCB;

    std::vector<std::function<void(void)>> disconnCB;

    std::string PKFile, SKFile;

    std::string ServerPKFile;
};
 
#endif //_CLIENT_H