udp.h

Go to the documentation of this file.

 
#ifndef MAXOS_NET_UDP_H
#define MAXOS_NET_UDP_H
 
 
#include <cstdint>
#include <common/eventHandler.h>
#include <net/ipv4.h>
#include <memory/memorymanagement.h>
 
 
namespace MaxOS::net {
 
    typedef struct PACKED UDPHeader {
 
        uint16_t source_port;            
        uint16_t destination_port;       
        uint16_t length;                
        uint16_t checksum;              
 
    } udp_header_t;
 
    enum class UDPEvents {
        DATA_RECEIVED,
    };
 
    //Predefine
    class UDPSocket;
 
    class UserDatagramProtocolHandler;
 
    typedef uint16_t UserDatagramProtocolPort;      
 
    class UDPDataReceivedEvent : public common::Event<UDPEvents> {
        public:
            UDPSocket* socket;     
            uint8_t* data;                          
            uint16_t size;                          
 
            UDPDataReceivedEvent(UDPSocket* socket, uint8_t* data, uint16_t size);
            ~UDPDataReceivedEvent();
    };
 
    class UDPPayloadHandler : public common::EventHandler<UDPEvents> {
        public:
            UDPPayloadHandler();
            ~UDPPayloadHandler();
 
            common::Event<UDPEvents>* on_event(common::Event<UDPEvents>* event) override;
 
            virtual void handle_user_datagram_protocol_message(UDPSocket* socket, uint8_t* data, uint16_t size);
 
    };
 
    class UDPSocket : public common::EventManager<UDPEvents> {
            friend class UserDatagramProtocolHandler;
 
        protected:
            bool listening;                
 
            uint16_t local_port = 0;         
            uint16_t remote_port = 0;        
 
            uint32_t local_ip = 0;           
            uint32_t remote_ip = 0;          
 
            UserDatagramProtocolHandler* user_datagram_protocol_handler;   
 
        public:
            UDPSocket();
            ~UDPSocket();
 
            virtual void handle_user_datagram_protocol_payload(uint8_t* data, uint16_t size);
            virtual void send(uint8_t* data, uint16_t size);
            virtual void disconnect();
 
    };
 
    class UserDatagramProtocolHandler : IPV4PayloadHandler {
        protected:
            common::Vector<UDPSocket*> sockets;    
            static UserDatagramProtocolPort free_ports;              
            common::OutputStream* errorMessages;                    
 
        public:
            UserDatagramProtocolHandler(InternetProtocolHandler* internet_protocol_handler, common::OutputStream* error_messages);
            ~UserDatagramProtocolHandler();
 
            bool handle_internet_protocol_payload(net::InternetProtocolAddress source_ip, net::InternetProtocolAddress destination_ip, uint8_t* payload_data, uint32_t size) override;
 
            UDPSocket* connect(uint32_t ip, uint16_t port);
            static UDPSocket* connect(const string& address);
 
            UDPSocket* listen(uint16_t port);
 
            void disconnect(UDPSocket* socket);
            void send(UDPSocket* socket, const uint8_t* data, uint16_t size);
 
            static void bind(UDPSocket* socket, UDPPayloadHandler* udp_payload_handler);
    };
 
}
 
 
#endif //MAXOS_NET_UDP_H