client.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_dfd7f74406ecd7bf1a137eafe457ab52dcb9c50fe177017cc67b73de69834ecb
#define USGOV_dfd7f74406ecd7bf1a137eafe457ab52dcb9c50fe177017cc67b73de69834ecb
 
#include <us/gov/crypto/symmetric_encryption.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <string>
#include <vector>
#include <unordered_map>
#include <csignal>
#include <cassert>
#include <memory>
#include <atomic>
#include <iostream>
#include "datagram.h"
#include <us/gov/config.h>
#include <condition_variable>
#include "send_queue.h"
#include "busyled.h"
 
namespace us { namespace gov {
namespace socket {
    using namespace std;
    using us::ko;
 
    struct server;
 
    struct client {
 
        typedef us::gov::socket::send_queue_t queue_t;
 
        static const char *KO_7190,*KO_58961,*KO_60541,*KO_10100,*KO_20190,*KO_20191;
 
        enum security_level_t {
            security_level_ok,
            security_level_disconnect,
            security_level_ban,
        };
 
        client();
        client(int sock);
        virtual ~client();
        ko connect0(uint32_t host, uint16_t port, bool block);
        ko connect0(const string& host, uint16_t port, bool block);
        virtual void disconnect(uint16_t seq, const string& reason);
        virtual pair<security_level_t,string> security_level() const { return make_pair(security_level_ok,""); }
        inline bool connected() const { return sock!=-1 && !finished.load(); }
        pair<uint32_t,uint16_t> raddress() const;
        virtual pair<ko, datagram*> encrypt0(datagram*d) const;
        virtual pair<ko, datagram*> decrypt0(datagram*d) const;
        //virtual datagram* encrypt0(datagram&d) const;
        virtual void on_connect(ko);
        pair<ko,datagram*> recv4x(datagram*d); //used by manager clients
        pair<ko,datagram*> recv6(); //used by auto responder
        chrono::system_clock::time_point since;
        chrono::system_clock::time_point activity_recv;
        chrono::system_clock::time_point last_test_alive;
        atomic<uint64_t> activity;
        ko init_sock2(uint32_t host, uint16_t port, bool block);
        void dump(const string& prefix, ostream& os) const;
        virtual void dump_all(const string& prefix, ostream& os) const { dump(prefix, os); }
        static uint32_t host2addr(const string& host);
        static string age(uint64_t msts);
        static string age(chrono::system_clock::time_point time);
        string refdata() const;
        static string ip4_decode(uint32_t addr);
        static uint32_t ip4_encode(const string& addr);
        static bool is_wan_ip(uint32_t);
        static bool is_valid_ip(uint32_t);
        string endpoint() const; //IP:PORT
        static string endpoint(uint32_t addr, uint16_t port);
        static string endpoint(const pair<uint32_t,uint16_t>& ip);
        static pair<ko,pair<string,uint16_t>> parse_endpoint(const string& ipport);
        virtual ko send1(datagram*);
        void prepare_worker_recv();
        void worker_ended_recv();
       // void add_finishing_reason(uint16_t seq, const string& reason);
        void set_finished();
        inline bool is_finished() const { return finished.load(); }
//        inline const string& get_finished_reason() const { return finished_reason; }
        void test_alive();
        void ping();
 
        static busyled_t busyled_recv;
        atomic<int> busyrecv{0};
        static struct timeval timeout;
        int sock;
        uint32_t address;
        uint16_t port;
        atomic<int> sendref{0};
        server* parent{nullptr}; //weak pointer
        queue_t* sendq{nullptr}; //weak pointer
 
        pair<uint16_t, string> finished_reason;
        atomic<bool> finished{false};
 
        #if CFG_COUNTERS==1
        public:
            struct counters_t {
                uint32_t attempt_read_fragment{0};
                uint32_t disconnection_wrong_read{0};
                uint32_t unknown_hostname{0};
                uint32_t connection_refused{0};
                uint32_t busy_outbound_pipe{0};
                void dump(ostream&os) const;
            };
            static counters_t counters;
        #endif
 
        #if CFG_LOGS==1
        public:
            string logdir;
        #endif
    };
 
}
}}
 
#endif