datagram.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_39bdfeac516fc1718aed51b86fa8d93d0d07d38ad969652da578521c0fd96067
#define USGOV_39bdfeac516fc1718aed51b86fa8d93d0d07d38ad969652da578521c0fd96067
 
#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 <mutex>
#include <us/gov/crypto/ripemd160.h>
#include <us/gov/crypto/sha256.h>
#include <us/gov/crypto/ec.h>
#include <us/gov/id/protocol.h>
#include <us/gov/socket/protocol.h>
#include <us/gov/likely.h>
#include <us/gov/config.h>
#include <atomic>
#include <type_traits>
 
namespace us { namespace gov {
namespace socket {
    using namespace std;
 
    struct datagram final:vector<uint8_t> {
        typedef vector<uint8_t> b;
        typedef crypto::ripemd160 hasher_t;
        typedef hasher_t::value_type hash_t;
        typedef int64_t cash_t;
        typedef crypto::sha256 sighasher_t;
        typedef sighasher_t::value_type sighash_t;
        typedef crypto::ec::keys::pub_t pub_t;
        typedef crypto::ec::keys::priv_t priv_t;
 
        static const char *KO_0001;
        static const char *KO_0002;
        static const char *KO_0003;
        static const char *KO_4038;
        static const char *KO_4921;
        static const char *KO_9021;
 
        struct dispatcher_t {
            virtual ~dispatcher_t() {}
            virtual void dispatch(datagram*);
        };
 
        #if CFG_COUNTERS==1
            struct iodata {
                iodata() {}
                struct data {
                    void dump(ostream& os) const;
                    void to_stream(ostream& os) const;
                    atomic<uint32_t> num{0};
                    atomic<uint32_t> bytes{0};
                };
                void dump(ostream& os) const;
                void to_stream(ostream& os) const;
                data sent;
                data received;
            };
 
            struct counters_t:unordered_map<uint16_t,iodata*> {
                counters_t();
                ~counters_t();
                uint32_t wrong_channel{0};
                uint32_t closed_connection{0};
                uint32_t peer_timeout{0};
                uint32_t peer_ended{0};
                uint32_t infraheader_datagram{0};
                uint32_t wrong_size{};
                uint32_t valid_dgram_fragment1{0};
                uint32_t valid_dgram_fragment2{0};
                uint64_t bytes_received{0};
                void update(const datagram& d, bool send);
                void dump(ostream& os) const;
                void dump_bw(const chrono::system_clock::time_point&, ostream& os) const;
                void to_stream_io(ostream& os) const;
                pair<uint32_t,uint32_t> totals() const;
            };
            static counters_t counters;
        #endif
 
        static constexpr size_t offset_channel{0};
        static constexpr size_t size_channel{sizeof(uint16_t)};
        static constexpr size_t offset_size{offset_channel+size_channel};
        static constexpr size_t size_size{sizeof(uint32_t)};
        static constexpr size_t offset_service{offset_size+size_size};
        static constexpr size_t size_service{sizeof(uint16_t)};
        static constexpr size_t offset_sequence{offset_size+size_size+size_service};
        static constexpr size_t size_sequence{sizeof(uint16_t)};
 
        static constexpr size_t h{size_channel+size_size+size_service+size_sequence};
        static constexpr size_t maxsize{CFG_MAX_SIZE_DATAGRAM};
        static string service_str(uint16_t svc);
 
        datagram();
        ~datagram();
        datagram(const datagram&);
        void constructor(uint16_t service, uint16_t sequence, uint32_t size);
 
        //datagram(uint16_t,uint16_t, const hash_t& , const uint8_t&,const string&,const tuple<int, int, int, int>&);
 
        #include <us/api/apitool_generated__c++__datagram_hdr>
 
/*
        template<typename t>
        datagram(uint16_t service, uint16_t sequence, const vector<t>& content):service(service) {
            static_assert(!is_same<t,size_t>::value,"not a suitable type for a network protocol. (sizeof mismatch across arch)");
            static_assert(!is_same<t,int>::value,"not a suitable type for a network protocol. (sizeof mismatch across arch)");
            assert(h+content.size()*sizeof(t)<maxsize);
            constructor(service,sequence,h+content.size()*sizeof(t));
            ::memcpy(data()+h,content.data(),content.size()*sizeof(t));
            //#ifdef FIND_DGRAM_LEAKS
            //    x.emplace(this);
            //#endif
        }
*/
 
        string parse_string() const;
        //uint16_t parse_uint16() const;
        //uint64_t parse_uint64() const;
/*
        bool parse(uint16_t&, uint16_t&) const; //P-uint16-uint16
        bool parse(uint16_t&, uint16_t&, uint16_t&) const; //P-uint16-uint16-uint16
        bool parse(uint16_t&, uint16_t&, uint16_t&, string&) const; //P-uint16-uint16-uint16-s
        bool parse(hash_t&) const; //P-h
        bool parse(sighash_t&) const; //P-sigh
        bool parse(hash_t&, string&) const; //P-hs
        bool parse(hash_t&, hash_t&) const; //P-hh
        bool parse(hash_t&, vector<unsigned char>&) const; //P-hv
        bool parse(sighash_t&, pub_t&, vector<unsigned char>&) const; //P-sigh-pub-v
        bool parse(pub_t&, vector<unsigned char>&) const; //P-pub-v
        bool parse(hash_t&, string&, vector<unsigned char>&) const; //P-hsv
        bool parse(hash_t&, string&, hash_t&) const;  //P-hsh
        bool parse(unsigned char&, vector<unsigned char>&) const;  //P-cv
        bool parse(unsigned char&, string&) const;  //P-cs
        bool parse(string&, string&) const; //P-ss
        bool parse(string&, string&, string&) const; //P-sss
        bool parse(vector<unsigned char>&) const; //P-v
*/
        bool completed() const;
        hash_t compute_hash() const;
        hash_t compute_hash_payload() const;
        inline string service_str() const { return service_str(service); }
        ko recvfrom(int sock);
 
        pair<ko,datagram*> encrypt(crypto::symmetric_encryption&) const;
        pair<ko,datagram*> decrypt(crypto::symmetric_encryption&) const;
 
        template<typename t>
        ko parse(vector<t>& content) const {
            if (unlikely(size()<h)) return (ko)"KO 81198 Invalid size.";
            auto payload_sz=size()-h;
            if (unlikely((payload_sz%sizeof(t))!=0)) return (ko)"KO 48535 Invalid size.";
            content.resize(payload_sz/sizeof(t));
            ::memcpy(content.data(),data()+h,payload_sz);
            return ok;
        }
 
        void dump(ostream&) const;
        uint32_t decode_size() const;
        uint16_t decode_service() const;
        uint16_t decode_sequence() const;
        void encode_size(uint32_t);
        void encode_service(uint16_t);
        void encode_sequence(uint16_t);
        void encode_channel();
        uint16_t decode_channel() const;
        static bool validate_payload(const string& payload);
        static bool validate_payload(const vector<unsigned char>&);
 
        template<typename t>
        static bool validate_payload(const vector<t>& payload) {
            return h+payload.size()*sizeof(t)<maxsize;
        }
 
        ko write_bin(ostream&) const;
        string header_bytes() const;
 
        static uint16_t system_channel;
        uint16_t service;
        uint32_t dend;
    };
}
}}
 
#endif