peer_t.h

Go to the documentation of this file.

/*
-------------------------------------------------------------------------------
                            PLEBBLE
-------------------------------------------------------------------------------
 Copyright (C) 2019-2020 KATLAS Technology. (http://katlastechnology.com)
 Copyright (C) 2017-2020 Marcos Mayorga. (mm@mm-studios.com)
 
 This file is part of our Plebble(R) Platform.
 
 The code below cannot be copied, used for any purpose other than the one
 agreed and/or distributed without the express permission of
 KATLAS Technology.
-------------------------------------------------------------------------------
 
 
*/
#ifndef USGOV_adb8d14e20731e001ab4e0eb7742ff5881fc9a7fabb4666497868c91f9a18570
#define USGOV_adb8d14e20731e001ab4e0eb7742ff5881fc9a7fabb4666497868c91f9a18570
 
#include <us/gov/socket/peer_t.h>
#include <mutex>
#include <condition_variable>
#include <us/gov/crypto/crypto.h>
#include <us/gov/crypto/hash.h>
#include <us/gov/crypto/symmetric_encryption.h>
#include <us/gov/config.h>
 
namespace us { namespace gov {
namespace id {
    using namespace std;
    using us::ko;
 
    struct daemon;
 
    struct peer_t:socket::peer_t {
        typedef socket::peer_t b;
        typedef crypto::ec::keys keys;
        typedef keys::pub_t pub_t;
        typedef pub_t::hash_t hash_t;
        using datagram=socket::datagram;
 
        static const char* KO_6017;
 
        enum stage_t { //coupled with sdk/java/src/Wallet.java
            anonymous=0,
            verified,
            verified_fail,
            num_stages
        };
        constexpr static array<const char*,num_stages> stagestr={"anonymous","verified","verified_fail"};
 
        enum role_t {
            role_peer=0,
            role_sysop=1,
            role_device=2,
            num_roles
        };
        constexpr static array<const char*,num_roles> rolestr={"peer","sysop","device"};
 
        peer_t(int sock);
        virtual ~peer_t();
 
        ko connect(const string& host, uint16_t port, uint16_t pport, role_t, bool block);
        virtual ko connect(uint32_t host, uint16_t port, uint16_t pport, role_t, bool block);
        virtual void verification_completed(uint16_t rpport) {}
        virtual const keys& get_keys() const;
        virtual void dump_all(const string& prefix, ostream& os) const override;
        void dump(const string& prefix, ostream& os) const;
        bool process_work(datagram*d);
        void process_request(datagram* d, const keys&);
        void process_peer_challenge(datagram* d, const keys&);
        void process_challenge_response(datagram* d);
        ko initiate_dialogue(role_t role, uint16_t pport_pin);
        static string to_string(const vector<unsigned char>& data);
        bool verification_is_fine() const { return get_stage_peer()==verified; }
        string short_version() const;
        ko turn_on_encryption();
        ko wait_auth() const;
        pair<ko, datagram*> encrypt0(datagram*) const override;
        pair<ko, datagram*> decrypt0(datagram*) const override;
        //datagram* encrypt0(const datagram&) const override;
        void disconnect(uint16_t seq, const string&reason) override;
        stage_t get_stage_peer() const;
        void set_stage_peer(stage_t);
 
        daemon* get_parent();
        const daemon* get_parent() const;
 
        inline bool is_role_peer() const { return role==role_peer; }
        inline bool is_role_sysop() const { return role==role_sysop; }
        inline bool is_role_device() const { return role==role_device; }
 
        struct handshake_t {
            typedef crypto::ec::sigmsg_hasher_t sigmsg_hasher_t;
            typedef sigmsg_hasher_t::value_type sigmsg_hash_t;
            handshake_t(role_t role, uint16_t pport);
            handshake_t();
            role_t parse_role() const;
            uint16_t parse_version_fingerprint() const;
            uint16_t parse_pport() const;
            uint16_t parse_pin() const;
            void dump(const string& pfx, ostream&os) const;
 
            sigmsg_hash_t msg;
        };
        struct handshakes_t {
            handshakes_t(role_t role, uint16_t pport);
            handshakes_t();
            ~handshakes_t();
            handshake_t* me{nullptr};
            handshake_t* peer{nullptr};
        };        
 
        stage_t stage_peer{anonymous};
        handshakes_t* handshakes{nullptr};
        role_t role{role_peer};
        pub_t pubkey; //peer's public key
        uint16_t version_fingerprint{0};
        mutable mutex mx_auth;
        mutable condition_variable cv_auth;
        mutable crypto::symmetric_encryption* se{nullptr};
    };
 
}
}}
 
#endif