MaxOS::net::UserDatagramProtocolHandler Class Reference

Handles the UDP protocol. More...

#include <udp.h>

Inheritance diagram for MaxOS::net::UserDatagramProtocolHandler:

Public Member Functions
	UserDatagramProtocolHandler (InternetProtocolHandler *internet_protocol_handler, common::OutputStream *error_messages)
	Construct a new User Datagram Protocol Handler object.
bool	handle_internet_protocol_payload (net::InternetProtocolAddress source_ip, net::InternetProtocolAddress destination_ip, uint8_t *payload_data, uint32_t size) override
	Handle the recivement of an UDP packet.
UDPSocket *	connect (uint32_t ip, uint16_t port)
UDPSocket *	listen (uint16_t port)
	Listens for incoming packets on the port.
void	disconnect (UDPSocket *socket)
	Disconnects the socket from the remote IP and port.
void	send (UDPSocket *socket, const uint8_t *data, uint16_t size)
	Sends a packet to the remote IP and port.

Static Public Member Functions
static UDPSocket *	connect (const string &address)
	Connects to a remote host through the UDP protocol.
static void	bind (UDPSocket *socket, UDPPayloadHandler *udp_payload_handler)
	Binds a handler to the socket.

Protected Attributes
common::Vector< UDPSocket * >	sockets
	The list of UDP sockets.
common::OutputStream *	errorMessages
	Where to write error messages.

Static Protected Attributes
static UserDatagramProtocolPort	free_ports = 0x8000
	The next free port number.

Detailed Description

Handles the UDP protocol.

Definition at line 113 of file udp.h.

Constructor & Destructor Documentation

UserDatagramProtocolHandler()

UserDatagramProtocolHandler::UserDatagramProtocolHandler	(	InternetProtocolHandler *	internet_protocol_handler,
		common::OutputStream *	error_messages
	)

Construct a new User Datagram Protocol Handler object.

Parameters

internet_protocol_handler	The Internet protocol handler
error_messages	Where to write error messages

Definition at line 112 of file udp.cpp.

: IPV4PayloadHandler(internet_protocol_handler, 0x11)    //0x11 is the UDP protocol number
{
    this -> errorMessages = error_messages;
}

References errorMessages.

Member Function Documentation

bind()

void UserDatagramProtocolHandler::bind ( UDPSocket *  socket, UDPPayloadHandler *  udp_payload_handler  )

static

Binds a handler to the socket.

Parameters

socket	The socket to bind the handler to
udp_payload_handler	The handler to bind

Definition at line 308 of file udp.cpp.

                                                                                                {
 
  socket->m_handlers.push_back(udp_payload_handler);                                                                //Set the handler of the socket to the handler that was passed in
 
 
}

References MaxOS::common::EventManager< EventType >::m_handlers.

connect() [1/2]

UDPSocket * UserDatagramProtocolHandler::connect ( const string &  address )

static

Connects to a remote host through the UDP protocol.

Parameters

address

The address to connect to in the form "IP:PORT"

Returns

The socket that is connected to the remote host, nullptr if it failed

Todo:

Implement string parsing to extract IP and port

Definition at line 211 of file udp.cpp.

                                                                     {
 
  return nullptr;
}

connect() [2/2]

UDPSocket * UserDatagramProtocolHandler::connect	(	uint32_t	ip,
		uint16_t	port
	)

Connects the socket to the remote IP and port

Parameters

ip	The remote IP address in big endian
port	The remote port

Returns

The socket that was connected

Definition at line 181 of file udp.cpp.

                                                                          {
 
 
    auto* socket = (UDPSocket*)MemoryManager::kmalloc(sizeof(UDPSocket));   //Allocate memory for the socket
 
    if(socket != nullptr) //If the socket was created
    {
        new (socket) UDPSocket();    //Create the socket
 
        //Configure the socket
        socket -> remote_port = port;                                    //Port to that application wants to connect to
        socket -> remote_ip = ip;                                        //IP to that application wants to connect to
        socket -> local_port = free_ports++;                               //Port that we will use to connect to the remote application  (note, local port doesnt have to be the same as remote)
        socket -> local_ip = internet_protocol_handler->get_internet_protocol_address();    //IP that we will use to connect to the remote application
        socket -> user_datagram_protocol_handler = this;                    //Set the UDP handler
 
        sockets.push_back(socket);                                       //Add the socket to the list of sockets
    }
 
    return socket;                                        //Return the socket
}

References free_ports, MaxOS::net::InternetProtocolHandler::get_internet_protocol_address(), MaxOS::net::IPV4PayloadHandler::internet_protocol_handler, MaxOS::memory::MemoryManager::kmalloc(), and sockets.

disconnect()

void UserDatagramProtocolHandler::disconnect

(

UDPSocket *

socket

)

Disconnects the socket from the remote IP and port.

Parameters

socket

The socket to disconnect

Definition at line 248 of file udp.cpp.

                                                              {
 
 
    for(Vector<UDPSocket*>::iterator current_socket = sockets.begin(); current_socket != sockets.end(); current_socket++) {
        if((*current_socket) == socket)                               //If the socket is the same as the socket that is being checked
        {
            sockets.erase(current_socket);                            //Remove the socket from the list of sockets
            MemoryManager::kfree(socket);      //Free the socket
            break;                                                   //Break out of the loop
        }
    }
 
}

References MaxOS::memory::MemoryManager::kfree(), and sockets.

Referenced by MaxOS::net::UDPSocket::disconnect().

handle_internet_protocol_payload()

bool UserDatagramProtocolHandler::handle_internet_protocol_payload ( net::InternetProtocolAddress  source_ip, net::InternetProtocolAddress  destination_ip, uint8_t *  payload_data, uint32_t  size  )

overridevirtual

Handle the recivement of an UDP packet.

Parameters

source_ip	The source IP address in big endian
destination_ip	The destination IP address in big endian
payload_data	The UDP payload
size	The size of the UDP payload

Returns

True if the packet is to be sent back to the sender

Reimplemented from MaxOS::net::IPV4PayloadHandler.

Definition at line 129 of file udp.cpp.

                                                                                                                                                                                        {
 
    //Check the size
    if(size < sizeof(UDPHeader)) {
        return false;
    }
 
    //Get the header
    auto* header = (UDPHeader*)payload_data;
 
    //Set the local and remote ports
    uint16_t local_port = header -> destination_port;
    uint16_t remote_port = header -> source_port;
 
    UDPSocket* socket = nullptr;                     //The socket that will be used
    for(auto & current_socket : sockets) {
        if(current_socket->local_port == local_port                  //If the local port (header dst, our port) is the same as the local port of the socket
        && current_socket->local_ip == destination_ip                     //If the local IP (packet dst, our IP) is the same as the local IP of the socket
        && current_socket->listening)                              //If the socket is listening
        {
 
            socket = current_socket;                               //Set the socket to the socket that is being checked
            socket->listening = false;                         //Set the socket to not listening, as it is now in use
            socket->remote_port = remote_port;                   //Set the remote port of the socket to the remote port of the packet
            socket->remote_ip = source_ip;                       //Set the remote IP of the socket to the remote IP of the packet
 
        }else if(current_socket->local_port == local_port            //If the local port (header dst, our port) is the same as the local port of the socket
              && current_socket->local_ip == destination_ip              //If the local IP (packet dst, our IP) is the same as the local IP of the socket
              && current_socket->remote_port == remote_port         //If the remote port (header src, their port) is the same as the remote port of the socket
              && current_socket->remote_ip == source_ip)            //If the remote IP (packet src, their IP) is the same as the remote IP of the socket
        {
            socket = current_socket;                               //Set the socket to the current socket
        }
 
    }
 
    if(socket != nullptr) {                                          //If the socket is not null then pass the data to the socket
        socket->handle_user_datagram_protocol_payload(payload_data + sizeof(UDPHeader),
                                                      size - sizeof(UDPHeader));
    }
 
    //UDP doesn't send back packets, so always return false
    return false;
 
}

References MaxOS::net::UDPSocket::handle_user_datagram_protocol_payload(), MaxOS::net::UDPSocket::listening, MaxOS::net::UDPSocket::remote_ip, MaxOS::net::UDPSocket::remote_port, and sockets.

listen()

UDPSocket * UserDatagramProtocolHandler::listen

(

uint16_t

port

)

Listens for incoming packets on the port.

Parameters

port	The port to listen on

Returns

The socket that is listening

Definition at line 222 of file udp.cpp.

                                                            {
 
    auto* socket = (UDPSocket*)MemoryManager::kmalloc(sizeof(UDPSocket));   //Allocate memory for the socket
 
    if(socket != nullptr) //If the socket was created
    {
        new (socket) UDPSocket();    //Create the socket
 
        //Configure the socket
        socket -> listening = true;                                     //Set the socket to listening
        socket -> local_port = port;                                     //Port that we will use to connect to the remote application  (note, local port doesnt have to be the same as remote)
        socket -> local_ip = internet_protocol_handler->get_internet_protocol_address();    //IP that we will use to connect to the remote application
        socket -> user_datagram_protocol_handler = this;                    //Set the UDP handler
 
        sockets.push_back(socket);                                       //Add the socket to the list of sockets
    }
 
    return socket;                                        //Return the socket
 
}

References MaxOS::net::InternetProtocolHandler::get_internet_protocol_address(), MaxOS::net::IPV4PayloadHandler::internet_protocol_handler, MaxOS::memory::MemoryManager::kmalloc(), and sockets.

send()

void UserDatagramProtocolHandler::send	(	UDPSocket *	socket,
		const uint8_t *	data,
		uint16_t	size
	)

Sends a packet to the remote IP and port.

Parameters

socket	The socket to send the packet from
data	The data to send
size	The size of the data

Definition at line 269 of file udp.cpp.

                                                                                            {
 
    uint16_t total_size = sizeof(UDPHeader) + size;                                 //Get the total size of the packet
    auto* buffer = (uint8_t*)MemoryManager::kmalloc(total_size);          //Allocate memory for the packet
    uint8_t* buffer2 = buffer + sizeof(UDPHeader);                                 //Get the buffer that will be used to store the data
 
    auto* header = (UDPHeader*)buffer;                       //Create the header of the packet
 
    //Set the header
    header -> source_port = socket -> local_port;                                                    //Set the source port to the local port of the socket    (this is the port that the packet will be sent from)
    header -> destination_port = socket -> remote_port;                                              //Set the destination port to the remote port of the socket (this is the port that the packet will be sent to)
    header -> length = ((total_size & 0x00FF) << 8) | ((total_size & 0xFF00) >> 8);                  //Set the length of the packet
 
    // Convert the ports into big endian
    header -> source_port = ((header -> source_port & 0x00FF) << 8) | ((header -> source_port & 0xFF00) >> 8);
    header -> destination_port = ((header -> destination_port & 0x00FF) << 8) | ((header -> destination_port & 0xFF00) >> 8);
 
    //Copy the data to the buffer
    for (int i = 0; i < size; ++i) {                                                               //Loop through the data
        buffer2[i] = data[i];                                                                      //Copy the data to the buffer
    }
 
    //Set the checksum
    header -> checksum = 0;                                                                        //Set the checksum to 0, this is becuase UDP doesnt have to have a checksum
 
    //Send the packet
    IPV4PayloadHandler::send(socket->remote_ip, buffer, total_size);
 
    //Free the buffer
    MemoryManager::kfree(buffer);
 
}

References MaxOS::memory::MemoryManager::kfree(), MaxOS::memory::MemoryManager::kmalloc(), MaxOS::net::UDPSocket::remote_ip, and MaxOS::net::IPV4PayloadHandler::send().

Referenced by MaxOS::net::UDPSocket::send().

Member Data Documentation

errorMessages

common::OutputStream* MaxOS::net::UserDatagramProtocolHandler::errorMessages

protected

Where to write error messages.

Definition at line 117 of file udp.h.

Referenced by UserDatagramProtocolHandler().

free_ports

UserDatagramProtocolPort UserDatagramProtocolHandler::free_ports = 0x8000

staticprotected

The next free port number.

Provider

Definition at line 116 of file udp.h.

Referenced by connect().

sockets

common::Vector<UDPSocket*> MaxOS::net::UserDatagramProtocolHandler::sockets

protected

The list of UDP sockets.

Definition at line 115 of file udp.h.

Referenced by connect(), disconnect(), handle_internet_protocol_payload(), and listen().

---

The documentation for this class was generated from the following files:

• /home/runner/work/MaxOS/MaxOS/kernel/include/net/udp.h
• /home/runner/work/MaxOS/MaxOS/kernel/src/net/udp.cpp