Handles TCP packets and manages TCP sockets. More...

#include <tcp.h>

Inheritance diagram for MaxOS::net::TransmissionControlProtocolHandler:

Public Member Functions
	TransmissionControlProtocolHandler (InternetProtocolHandler internet_protocol_handler, common::OutputStream error_messages)
	Construct a new Transmission Control 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 TCP message (provider end)

TCPSocket *	connect (InternetProtocolAddress ip, TransmissionControlProtocolPort port)
	connect to a remote host through the TCP protocol

void	disconnect (TCPSocket *socket)
	Begin the disconnect process.

virtual TCPSocket *	listen (uint16_t port)
	Begin listening on a port.

virtual void	bind (TCPSocket socket, TCPPayloadHandler handler)
	bind a data handler to this socket

Static Public Member Functions
static TCPSocket *	connect (const string &address)
	connect to a remote host through the TCP protocol

Protected Member Functions
void	send_transmission_control_protocol_packet (TCPSocket socket, const uint8_t data, uint16_t size, uint16_t flags=0)
	send a packet (Throught the provider)

Protected Attributes
common::OutputStream *	error_messages
	Where to write error messages.

common::Vector< TCPSocket * >	sockets
	The list of connected sockets.

Static Protected Attributes
static TransmissionControlProtocolPort	free_ports = 0x8000
	The next free port to use for new sockets.

Friends
class	TCPSocket

Detailed Description

Handles TCP packets and manages TCP sockets.

Definition at line 206 of file tcp.h.

Constructor & Destructor Documentation

◆ TransmissionControlProtocolHandler()

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

Construct a new Transmission Control Protocol Handler object.

Parameters

internet_protocol_handler	The Internet protocol handler
error_messages	Where to write error messages

Definition at line 160 of file tcp.cpp.

        : IPV4PayloadHandler(internet_protocol_handler, 0x06) {
    this->error_messages = error_messages;
 
}

References error_messages.

Member Function Documentation

◆ bind()

void TransmissionControlProtocolHandler::bind	(	TCPSocket *	socket,
		TCPPayloadHandler *	handler
	)

virtual

bind a data handler to this socket

Parameters

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

Definition at line 581 of file tcp.cpp.

                                                                                           {
    socket->connect_event_handler(handler);
}

References MaxOS::common::EventManager< EventType >::connect_event_handler().

◆ connect() [1/2]

TCPSocket * TransmissionControlProtocolHandler::connect ( const string & address )

static

connect to a remote host through the TCP 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 for address

Definition at line 527 of file tcp.cpp.

                                                                            {
 
    return nullptr;
}

◆ connect() [2/2]

TCPSocket * TransmissionControlProtocolHandler::connect	(	InternetProtocolAddress	ip,
		TransmissionControlProtocolPort	port
	)

connect to a remote host through the TCP protocol

Parameters

ip	The IP of the remote host
port	The port of the remote host

Returns: The socket that is connected to the remote host, 0 if it failed

Definition at line 484 of file tcp.cpp.

                                                                                                                       {
    //Create a new socket
    auto* socket = (TCPSocket*) MemoryManager::kmalloc(
            sizeof(TCPSocket));
 
    //If there is space for the socket
    if(socket != nullptr) {
        //Set the socket
        new(socket) TCPSocket(this);
 
        //Set local and remote addresses
        socket->remotePort = port;
        socket->remote_ip = ip;
        socket->local_port = free_ports++;
        socket->local_ip = internet_protocol_handler->get_internet_protocol_address();
 
        //Convert into big endian
        socket->remotePort = ((socket->remotePort & 0xFF00) >> 8) | ((socket->remotePort & 0x00FF) << 8);
        socket->local_port = ((socket->local_port & 0xFF00) >> 8) | ((socket->local_port & 0x00FF) << 8);
 
        //Set the socket into the socket array and then set its state
        sockets.push_back(socket);
        socket->state = TCPSocketState::SYN_SENT;
 
        //Dummy sequence number
        socket->sequence_number = 0xbeefcafe;
 
        //Send a sync packet
        send_transmission_control_protocol_packet(socket, nullptr, 0, (uint16_t) TCPFlag::SYN);
    }
 
    return socket;
}

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

◆ disconnect()

void TransmissionControlProtocolHandler::disconnect ( TCPSocket * socket )

Begin the disconnect process.

Parameters

socket The socket to disconnect

Definition at line 537 of file tcp.cpp.

                                                                     {
 
    socket->state = TCPSocketState::FIN_WAIT1;                            //Begin fin wait sequence
    send_transmission_control_protocol_packet(socket, nullptr, 0, (uint16_t) TCPFlag::FIN +
                                                                  (uint16_t) TCPFlag::ACK);            //Send FIN|ACK packet
    socket->sequence_number++;                             //Increase the sequence number
}

References send_transmission_control_protocol_packet(), MaxOS::net::TCPSocket::sequence_number, and MaxOS::net::TCPSocket::state.

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

◆ handle_internet_protocol_payload()

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

overridevirtual

Handle the TCP message (provider end)

Parameters

source_ip	The source IP address
destination_ip	The destination IP address
payload_data	The payload
size	The size of the payload

Returns: True if data is to be sent back or false if not

Reimplemented from MaxOS::net::IPV4PayloadHandler.

Definition at line 201 of file tcp.cpp.

                                                                                                                                                                                               {
 
    error_messages->write("TCP: Handling TCP message\n");
 
    //Check if the size is too small
    if(size < 13) {
        return false;
    }
 
    // If it's smaller than the header, return
    if(size < 4 * payload_data[12] / 16)             // The lower 4 bits of the 13th byte is the header length
    {
        return false;
    }
 
    //Get the header
    auto* msg = (TCPHeader*) payload_data;
 
    //Get the connection values (convert to host endian)
    uint16_t local_port = big_endian_16(msg->dst_port);
    uint16_t remote_port = big_endian_16(msg->src_port);
 
    //Create the socket
    TCPSocket* socket = nullptr;
 
    for(auto& current_socket : sockets) {
        if(current_socket->local_port ==
           local_port                               //Check if the local port is the same as the destination port
           && current_socket->local_ip ==
              destination_ip                                  //Check if the local IP is the same as the destination IP
           && current_socket->state ==
              TCPSocketState::LISTEN                                           //Check if the socket is in the LISTEN state
           && (((msg->flags) & ((uint16_t) TCPFlag::SYN | (uint16_t) TCPFlag::ACK)) ==
               (uint16_t) TCPFlag::SYN))                                       //Check if the SYN flag is set (allow for acknoweldgement)
        {
            socket = current_socket;
        } else if(current_socket->local_port ==
                  local_port                          //Check if the local port is the same as the destination port
                  && current_socket->local_ip ==
                     destination_ip                             //Check if the local IP is the same as the destination IP
                  && current_socket->remotePort ==
                     remote_port                         //Check if the remote port is the same as the source port
                  && current_socket->remote_ip ==
                     destination_ip)                           //Check if the remote IP is the same as the source IP
        {
            socket = current_socket;
        }
    }
 
 
    bool reset = false;
 
    //Check if the socket is found and if the socket wants to reset
    if(socket != nullptr && msg->flags & (uint16_t) TCPFlag::RST) {
        socket->state = TCPSocketState::CLOSED;
        socket->disconnected();
    }
 
    //Check if the socket is found and if the socket is not closed
    if(socket != nullptr && socket->state != TCPSocketState::CLOSED) {
        switch((msg->flags) & ((uint16_t) TCPFlag::SYN | (uint16_t) TCPFlag::ACK | (uint16_t) TCPFlag::FIN)) {
            /*
             * Example for explanation:
             * socket -> state = SYN_RECEIVED;                                                  //The state of the socket, e.g. recieved, or established. This is used to know how to handle the socket
             * socket -> remotePort = msg -> srcPort;                                           //The remote port, e.g. the port of the server
             * socket -> remoteIP = srcIP_BE;                                                   //The remote IP, e.g. the IP of the server
             * socket -> acknowledgementNumber = bigEndian32( msg -> sequenceNumber ) + 1;      //The acknowledgement number, the number used to keep track of what has been received, this is just incremented by 1 each time
             * socket -> sequenceNumber = 0xbeefcafe;                                           //The sequence number, the number of the next set that is to be sent but in this case sequence isn't enabled so just set it to anything
             * Send(socket, 0,0, SYN|ACK);                                                      //The response command, genneraly has to have the acknoledgement flag set
             * socket -> sequenceNumber++;                                                      //Increment the sequence number
             *
             */
 
            case (uint16_t) TCPFlag::SYN:
                if(socket->state == TCPSocketState::LISTEN) {
                    socket->state = TCPSocketState::SYN_RECEIVED;
                    socket->remotePort = msg->src_port;
                    socket->remote_ip = source_ip;
                    socket->acknowledgement_number = big_endian_32(msg->sequence_number) + 1;
                    socket->sequence_number = 0xbeefcafe;
                    send_transmission_control_protocol_packet(socket, nullptr, 0,
                                                              (uint16_t) TCPFlag::SYN | (uint16_t) TCPFlag::ACK);
                    socket->sequence_number++;
                } else
                    reset = true;
                break;
 
 
            case (uint16_t) TCPFlag::SYN | (uint16_t) TCPFlag::ACK:
                if(socket->state == TCPSocketState::SYN_SENT) {
                    socket->state = TCPSocketState::ESTABLISHED;
                    socket->acknowledgement_number = big_endian_32(msg->sequence_number) + 1;
                    socket->sequence_number++;
                    send_transmission_control_protocol_packet(socket, nullptr, 0, (uint16_t) TCPFlag::ACK);
                } else
                    reset = true;
                break;
 
 
            case (uint16_t) TCPFlag::SYN | (uint16_t) TCPFlag::FIN:
            case (uint16_t) TCPFlag::SYN | (uint16_t) TCPFlag::FIN | (uint16_t) TCPFlag::ACK:
                reset = true;
                break;
 
 
            case (uint16_t) TCPFlag::FIN:
            case (uint16_t) TCPFlag::FIN | (uint16_t) TCPFlag::ACK:
                if(socket->state == TCPSocketState::ESTABLISHED) {
                    socket->state = TCPSocketState::CLOSE_WAIT;
                    socket->acknowledgement_number++;
                    send_transmission_control_protocol_packet(socket, nullptr, 0, (uint16_t) TCPFlag::ACK);
                    send_transmission_control_protocol_packet(socket, nullptr, 0,
                                                              (uint16_t) TCPFlag::FIN | (uint16_t) TCPFlag::ACK);
                    socket->disconnected();
                } else if(socket->state == TCPSocketState::CLOSE_WAIT) {
                    socket->state = TCPSocketState::CLOSED;
                } else if(socket->state == TCPSocketState::FIN_WAIT1 || socket->state == TCPSocketState::FIN_WAIT2) {
                    socket->state = TCPSocketState::CLOSED;
                    socket->acknowledgement_number++;
                    send_transmission_control_protocol_packet(socket, nullptr, 0, (uint16_t) TCPFlag::ACK);
                    socket->disconnected();
                } else
                    reset = true;
                break;
 
 
            case (uint16_t) TCPFlag::ACK:
                if(socket->state == TCPSocketState::SYN_RECEIVED) {
                    socket->state = TCPSocketState::ESTABLISHED;
                    socket->connected();
                    return false;
                } else if(socket->state == TCPSocketState::FIN_WAIT1) {
                    socket->state = TCPSocketState::FIN_WAIT2;
                    return false;
                } else if(socket->state == TCPSocketState::CLOSE_WAIT) {
                    socket->state = TCPSocketState::CLOSED;
                    break;
                }
 
                if(msg->flags == (uint16_t) TCPFlag::ACK)
                    break;
 
                // no break, because of piggybacking
                [[fallthrough]];
 
            default:
 
                // By default, handle the data
 
                if(big_endian_32(msg->sequence_number) == socket->acknowledgement_number) {
 
                    reset = !(socket->handle_transmission_control_protocol_payload(
                            payload_data + msg->header_size_32 * 4,
                            size - msg->header_size_32 * 4));
                    if(!reset) {
                        uint32_t x = 0;                                                                      //The number of bytes to send back
                        for(uint32_t i = msg->header_size_32 * 4;
                            i < size; i++)                          //Loop through the data
                            if(payload_data[i] !=
                               0)                                                     //Check if the data is not 0
                                x = i;                                                                  //Set the number of bytes to send back to the current index
                        socket->acknowledgement_number += x - msg->header_size_32 * 4 +
                                                          1;               //Increment the acknowledgement number by the number of bytes to send back
                        send_transmission_control_protocol_packet(socket, nullptr, 0,
                                                                  (uint16_t) TCPFlag::ACK);                                          //Send the acknowledgement
                    }
                } else {
                    // data in wrong order
                    reset = true;
                }
 
        }
    }
 
 
    if(reset)                                                                       //If the socket is to be reset
    {
        if(socket !=
           nullptr)                                                             //If the socket exists then send a reset flag
        {
            send_transmission_control_protocol_packet(socket, nullptr, 0, (uint16_t) TCPFlag::RST);
        } else                                                                        //If it doesn't exist then create a new socket and send a reset flag
        {
            TCPSocket new_socket(this);                     //Create a new socket
            new_socket.remotePort = msg->src_port;                                         //Set the remote port
            new_socket.remote_ip = source_ip;                                                 //Set the remote IP
            new_socket.local_port = msg->dst_port;                                                  //Set the local port
            new_socket.local_ip = destination_ip;                                                     //Set the local IP
            new_socket.sequence_number = big_endian_32(
                    msg->acknowledgement_number);              //Set the sequence number
            new_socket.acknowledgement_number =
                    big_endian_32(msg->sequence_number) + 1;          //Set the acknowledgement number
            send_transmission_control_protocol_packet(&new_socket, nullptr, 0,
                                                      (uint16_t) TCPFlag::RST);          //Send the reset flag
        }
    }
 
 
    error_messages->write("TCP: Handled packet\n");
 
    if(socket != nullptr && socket->state ==
                            TCPSocketState::CLOSED)                                        //If the socket is closed then remove it from the list
    {
        sockets.erase(socket);
        return true;
    }
 
 
    return false;
}

References MaxOS::net::TCPSocket::acknowledgement_number, big_endian_16(), big_endian_32(), MaxOS::net::TCPSocket::connected(), MaxOS::net::TCPSocket::disconnected(), error_messages, MaxOS::net::TCPSocket::handle_transmission_control_protocol_payload(), MaxOS::net::TCPSocket::remote_ip, MaxOS::net::TCPSocket::remotePort, send_transmission_control_protocol_packet(), MaxOS::net::TCPSocket::sequence_number, sockets, MaxOS::net::TCPSocket::state, and MaxOS::common::OutputStream::write().

◆ listen()

TCPSocket * TransmissionControlProtocolHandler::listen ( uint16_t port )

virtual

Begin listening on a port.

Parameters

port	The port to listen on

Returns: The socket that will handle the connection

Definition at line 551 of file tcp.cpp.

                                                                   {
    //Create a new socket
    auto* socket = (TCPSocket*) MemoryManager::kmalloc(
            sizeof(TCPSocket));
 
    //If there is space for the socket
    if(socket != nullptr) {
        //Set the socket
        new(socket) TCPSocket(this);
 
        //Configure the socket
        socket->state = TCPSocketState::LISTEN;
        socket->local_ip = internet_protocol_handler->get_internet_protocol_address();
        socket->local_port = ((port & 0xFF00) >> 8) | ((port & 0x00FF) << 8);
 
        //Add the socket to the socket array
        sockets.push_back(socket);
    }
 
    //Return the socket
    return socket;
}

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

◆ send_transmission_control_protocol_packet()

void TransmissionControlProtocolHandler::send_transmission_control_protocol_packet	(	TCPSocket *	socket,
		const uint8_t *	data,
		uint16_t	size,
		uint16_t	flags = `0`
	)

protected

send a packet (Throught the provider)

Parameters

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

Definition at line 420 of file tcp.cpp.

                                                                                                                                                        {
    //Get the total size of the packet and the packet with the pseudo header
    uint16_t total_length = size + sizeof(TCPHeader);
    uint16_t length_incl_p_hdr = total_length + sizeof(TCPPseudoHeader);
 
    //Create a buffer for the packet
    auto* buffer = (uint8_t*) MemoryManager::kmalloc(length_incl_p_hdr);
    uint8_t* buffer2 =
            buffer + sizeof(TCPHeader) + sizeof(TCPPseudoHeader);
 
    //Create the headers
    auto* phdr = (TCPPseudoHeader*) buffer;
    auto* msg = (TCPHeader*) (buffer + sizeof(TCPPseudoHeader));
 
    //Size is translated into 32bit
    msg->header_size_32 = sizeof(TCPHeader) / 4;
 
    //Set the ports
    msg->src_port = big_endian_16(socket->local_port);
    msg->dst_port = big_endian_16(socket->remotePort);
 
    //Set TCP related data
    msg->acknowledgement_number = big_endian_32(socket->acknowledgement_number);
    msg->sequence_number = big_endian_32(socket->sequence_number);
    msg->reserved = 0;
    msg->flags = flags;
    msg->window_size = 0xFFFF;
    msg->urgent_ptr = 0;
 
    //Through the options allow for the MSS to be set
    msg->options = ((flags & (uint16_t) TCPFlag::SYN) != 0) ? 0xB4050402 : 0;
 
    //Increase the sequence number
    socket->sequence_number += size;
 
    // Check if the data is not null
    if(data != nullptr) {
        //Copy the data into the buffer
        for(int i = 0; i < size; i++)
            buffer2[i] = data[i];
    }
 
    //Set the pseudo header
    phdr->src_ip = socket->local_ip;
    phdr->dst_ip = socket->remote_ip;
    phdr->protocol = 0x0600;
    phdr->total_length = ((total_length & 0x00FF) << 8) | ((total_length & 0xFF00) >> 8);
 
    //Calculate the checksum
    msg->checksum = 0;
    msg->checksum = InternetProtocolHandler::checksum((uint16_t*) buffer, length_incl_p_hdr);
 
 
    //Send and then free the data
    send(socket->remote_ip, (uint8_t*) msg, total_length);
    MemoryManager::kfree(buffer);
}

References MaxOS::net::TCPSocket::acknowledgement_number, big_endian_16(), big_endian_32(), MaxOS::net::InternetProtocolHandler::checksum(), MaxOS::memory::MemoryManager::kfree(), MaxOS::memory::MemoryManager::kmalloc(), MaxOS::net::TCPSocket::local_ip, MaxOS::net::TCPSocket::local_port, MaxOS::net::TCPSocket::remote_ip, MaxOS::net::TCPSocket::remotePort, MaxOS::net::IPV4PayloadHandler::send(), and MaxOS::net::TCPSocket::sequence_number.

Referenced by connect(), disconnect(), handle_internet_protocol_payload(), and MaxOS::net::TCPSocket::send().

Friends And Related Symbol Documentation

◆ TCPSocket

friend class TCPSocket

friend

Definition at line 207 of file tcp.h.

Member Data Documentation

◆ error_messages

common::OutputStream* MaxOS::net::TransmissionControlProtocolHandler::error_messages

protected

Where to write error messages.

Definition at line 210 of file tcp.h.

Referenced by handle_internet_protocol_payload(), and TransmissionControlProtocolHandler().

◆ free_ports

TransmissionControlProtocolPort TransmissionControlProtocolHandler::free_ports = 0x8000

staticprotected

The next free port to use for new sockets.

Handler///

Definition at line 213 of file tcp.h.

Referenced by connect().

◆ sockets

common::Vector<TCPSocket*> MaxOS::net::TransmissionControlProtocolHandler::sockets

protected

The list of connected sockets.

Definition at line 211 of file tcp.h.

Referenced by connect(), 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/tcp.h
/home/runner/work/MaxOS/MaxOS/kernel/src/net/tcp.cpp

Public Member Functions

Static Public Member Functions

Protected Member Functions

Protected Attributes

Static Protected Attributes

Friends

Detailed Description

Constructor & Destructor Documentation

◆ TransmissionControlProtocolHandler()

Member Function Documentation

◆ bind()

◆ connect() [1/2]

◆ connect() [2/2]

◆ disconnect()

◆ handle_internet_protocol_payload()

◆ listen()

◆ send_transmission_control_protocol_packet()

Friends And Related Symbol Documentation

◆ TCPSocket

Member Data Documentation

◆ error_messages

◆ free_ports

◆ sockets