server.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_c240798d9f2ba9cd92a0728e617b7d39e33fe0519df7744799c27d2312bc782b
#define USGOV_c240798d9f2ba9cd92a0728e617b7d39e33fe0519df7744799c27d2312bc782b
 
#include <netinet/in.h>
#include <arpa/inet.h>
#include <string>
#include <vector>
#include <unordered_map>
#include <unordered_set>
#include <csignal>
#include <cassert>
#include <memory>
#include <mutex>
#include <condition_variable>
#include <random>
#include <thread>
#include <us/gov/crypto/ec.h>
#include <us/gov/config.h>
#include <us/gov/bgtask.h>
#include "client.h"
#include "datagram.h"
#include "clients.h"
#include <us/gov/config.h>
 
namespace us { namespace gov {
namespace socket {
    struct datagram;
 
    struct server: bgtask {
        typedef bgtask b;
        typedef crypto::ec::keys::pub_t pub_t;
 
        #if CFG_COUNTERS==1
            struct counters_t {
                uint32_t select_cycles{0};
                uint32_t select_errors{0};
                uint32_t select_EINTR{0};
                uint32_t select_EBADF{0};
                uint32_t new_connections{0};
                uint32_t closed_banned{0};
                uint32_t data_arrived_unmapped_fd{0};
                uint32_t blacklisted_addr{0};
                void dump(ostream& os) const;
            };
            static counters_t counters;
        #endif
 
        struct blacklist: unordered_map<uint32_t,pair<chrono::system_clock::time_point,string>> {
            static constexpr chrono::seconds bantime{300}; //5m;
            void add(uint32_t, const string& reason);
            void purge();
            void dump(ostream&) const;
        };
 
        server();
        server(uint16_t port);
        virtual ~server();
        virtual client* create_client(int sock);
        virtual void attach(client*);
        virtual void attach_noupdate(client*);
        virtual void detach(client*);
        virtual void receive_and_process(client*)=0;
        virtual void on_destroy(client&) {}
        datagram* read_from_client(int sock);
        int make_socket (uint16_t port);
        bool banned_throttle(const string& addr);
        void dump(const string& prefix, ostream& os) const;
        void proc_evil(const vector<pair<uint32_t,string>>&);
        static int set_not_blocking_mode(int sock);
        void run();
        void onwakeup();
        ko start() override;
        ko wait_ready(const chrono::system_clock::time_point& deadline) const override;
        void stop() override;
        void join() override;
 
        clients_t clients;
        uint16_t port;
        int sock{0};
        blacklist ban;
        client::queue_t sendq;
        #if CFG_LOGS==1
            string logdir;
        #endif
    };
}
}}
 
#endif