tcp.h

Go to the documentation of this file.

 
#ifndef MAXOS_NET_TCP_H
#define MAXOS_NET_TCP_H
 
#include <cstdint>
#include <net/ipv4.h>
#include <memory/memorymanagement.h>
 
 
namespace MaxOS::net {
 
    typedef uint16_t TransmissionControlProtocolPort;   
 
    enum class TCPSocketState {
        CLOSED,
        LISTEN,
        SYN_SENT,
        SYN_RECEIVED,
 
        ESTABLISHED,
 
        FIN_WAIT1,
        FIN_WAIT2,
        CLOSING,
        TIME_WAIT,
 
        CLOSE_WAIT,
        LAST_ACK
    };
 
    enum class TCPFlag {
        FIN = 1,
        SYN = 2,
        RST = 4,
        PSH = 8,
        ACK = 16,
        URG = 32,
        ECE = 64,
        CWR = 128,
        NS = 256
    };
 
    typedef struct PACKED TCPHeader {
 
        uint16_t src_port;                   
        uint16_t dst_port;                   
        uint32_t sequence_number;            
        uint32_t acknowledgement_number;     
 
        uint8_t reserved : 4;                
        uint8_t header_size_32 : 4;            
        uint8_t flags;                      
 
        uint16_t window_size;                
        uint16_t checksum;                  
        uint16_t urgent_ptr;                 
 
        uint32_t options;                   
 
    } tcp_header_t;
 
    typedef struct PACKED TCPPseudoHeader {
 
        uint32_t src_ip;         
        uint32_t dst_ip;         
        uint16_t protocol;      
        uint16_t total_length;   
 
    } tcp_pseudo_header_t;
 
 
    // Forward declarations
    class TCPSocket;
 
    class TransmissionControlProtocolHandler;
 
    enum class TCPPayloadHandlerEvents {
        CONNECTED,
        DISCONNECTED,
        DATA_RECEIVED
    };
 
    class DataReceivedEvent : public common::Event<TCPPayloadHandlerEvents> {
        public:
            TCPSocket* socket;       
            uint8_t* data;                                   
            uint16_t size;                                    
            DataReceivedEvent(TCPSocket* socket, uint8_t* data, uint16_t size);
            ~DataReceivedEvent();
    };
 
    class ConnectedEvent : public common::Event<TCPPayloadHandlerEvents> {
        public:
            TCPSocket* socket;                      
            explicit ConnectedEvent(TCPSocket* socket);
            ~ConnectedEvent();
    };
 
    class DisconnectedEvent : public common::Event<TCPPayloadHandlerEvents> {
        public:
            TCPSocket* socket;                      
            explicit DisconnectedEvent(TCPSocket* socket);
            ~DisconnectedEvent();
    };
 
    class TCPPayloadHandler : public common::EventHandler<TCPPayloadHandlerEvents> {
        public:
            TCPPayloadHandler();
            ~TCPPayloadHandler();
 
            common::Event<TCPPayloadHandlerEvents>* on_event(common::Event<TCPPayloadHandlerEvents>* event) override;
 
            virtual void handle_transmission_control_protocol_payload(TCPSocket* socket, uint8_t* data, uint16_t size);
            virtual void connected(TCPSocket* socket);
            virtual void disconnected(TCPSocket* socket);
    };
 
    class TCPSocket : public common::EventManager<TCPPayloadHandlerEvents> {
            friend class TransmissionControlProtocolHandler;
 
            friend class TransmissionControlProtocolPortListener;
 
        protected:
            uint16_t remotePort = 0;                    
            uint32_t remote_ip = 0;                      
            uint16_t local_port = 0;                     
            uint32_t local_ip = 0;                       
            uint32_t sequence_number = 0;                
            uint32_t acknowledgement_number = 0;         
 
            TransmissionControlProtocolHandler* transmission_control_protocol_handler;  
            TCPSocketState state;                                                    
        public:
            explicit TCPSocket(TransmissionControlProtocolHandler* transmission_control_protocol_handler);
            ~TCPSocket();
 
            virtual void send(uint8_t* data, uint16_t size);
            virtual void disconnect();
 
            void disconnected();
            void connected();
 
            bool handle_transmission_control_protocol_payload(uint8_t* data, uint16_t size);
    };
 
    class TransmissionControlProtocolHandler : IPV4PayloadHandler {
            friend class TCPSocket;
 
        protected:
            common::OutputStream* error_messages;                                
            common::Vector<TCPSocket*> sockets;         
 
            static TransmissionControlProtocolPort free_ports;                   
            void send_transmission_control_protocol_packet(TCPSocket* socket, const uint8_t* data, uint16_t size, uint16_t flags = 0);
 
        public:
            TransmissionControlProtocolHandler(InternetProtocolHandler* internet_protocol_handler, common::OutputStream* error_messages);
            ~TransmissionControlProtocolHandler();
 
            bool handle_internet_protocol_payload(net::InternetProtocolAddress source_ip, net::InternetProtocolAddress destination_ip, uint8_t* payload_data, uint32_t size) override;
 
            TCPSocket* connect(InternetProtocolAddress ip, TransmissionControlProtocolPort port);
            static TCPSocket* connect(const string& address);
 
            void disconnect(TCPSocket* socket);
 
            virtual TCPSocket* listen(uint16_t port);
            virtual void bind(TCPSocket* socket, TCPPayloadHandler* handler);
    };
 
 
}
 
 
#endif //MAXOS_NET_TCP_H