Handles IPv4 packets over Ethernet frames. More...

#include <ipv4.h>

Inheritance diagram for MaxOS::net::InternetProtocolHandler:

Public Member Functions
	InternetProtocolHandler (EthernetFrameHandler backend, InternetProtocolAddress own_internet_protocol_address, InternetProtocolAddress default_gateway_internet_protocol_address, SubnetMask subnet_mask, common::OutputStream error_messages)
	Construct a new Internet Protocol Handler object.

bool	handle_ethernetframe_payload (uint8_t *ethernetframe_payload, uint32_t size) override
	Called when an IP packet is received.

void	send_internet_protocol_packet (uint32_t dst_ip_be, uint8_t protocol, const uint8_t *data, uint32_t size)
	Sends an IP packet.

InternetProtocolAddress	get_internet_protocol_address () const
	Gets the IP address of this device.

drivers::ethernet::MediaAccessControlAddress	get_media_access_control_address ()
	Gets the MAC address of this device.

void	connect_ipv_4_payload_handler (IPV4PayloadHandler *ipv_4_payload_handler)
	Connects an IP protocol payload handler.

Public Member Functions inherited from MaxOS::net::EthernetFramePayloadHandler
	EthernetFramePayloadHandler (EthernetFrameHandler *frame_handler, uint16_t handled_type)
	Construct a new Ether Frame Payload Handler object.

	~EthernetFramePayloadHandler ()
	Destroy the EtherFrameHandler:: EtherFrameHandler object, Removes it from the handler list.

void	send (uint64_t destination, uint8_t *data, uint32_t size)
	send an packet via the backend driver

Static Public Member Functions
static uint16_t	checksum (const uint16_t *data, uint32_t length_in_bytes)
	Creates a checksum for the given data.

static InternetProtocolAddress	create_internet_protocol_address (uint8_t digit1, uint8_t digit2, uint8_t digit3, uint8_t digit4)
	Creates an IP address from four digits.

static InternetProtocolAddress	parse (string address)
	Parses a string representation of an IP address.

static SubnetMask	create_subnet_mask (uint8_t digit1, uint8_t digit2, uint8_t digit3, uint8_t digit4)
	Creates a subnet mask from four digits.

Protected Member Functions
void	register_ipv_4_address_resolver (IPV4AddressResolver *ipv4_resolver)
	Registers an IP address resolver.

Protected Attributes
common::Map< uint8_t, IPV4PayloadHandler * >	ipv_4_payload_handlers
	Map of IP protocol numbers to their payload handlers.

IPV4AddressResolver *	resolver = nullptr
	The IP address resolver.

common::OutputStream *	error_messages
	Stream to output error messages to.

InternetProtocolAddress	own_internet_protocol_address
	The IP address of this device.

InternetProtocolAddress	default_gateway_internet_protocol_address
	The IP address of the default gateway.

SubnetMask	subnet_mask
	The subnet mask.

Protected Attributes inherited from MaxOS::net::EthernetFramePayloadHandler
EthernetFrameHandler *	frame_handler
	The Ethernet frame handler this payload handler is connected to.

uint16_t	handled_type
	The Ethernet frame type this handler handles.

Friends
class	IPV4AddressResolver

Detailed Description

Handles IPv4 packets over Ethernet frames.

Definition at line 85 of file ipv4.h.

Constructor & Destructor Documentation

◆ InternetProtocolHandler()

InternetProtocolHandler::InternetProtocolHandler	(	EthernetFrameHandler *	backend,
		InternetProtocolAddress	own_internet_protocol_address,
		InternetProtocolAddress	default_gateway_internet_protocol_address,
		SubnetMask	subnet_mask,
		common::OutputStream *	error_messages
	)

Construct a new Internet Protocol Handler object.

Parameters

backend	The backend Ethernet frame handler.
own_internet_protocol_address	The IP address of this device.
default_gateway_internet_protocol_address	The IP address of the default gateway.
subnet_mask	The subnet mask.
error_messages	Where to write error messages.

Definition at line 110 of file ipv4.cpp.

: EthernetFramePayloadHandler(backend, 0x0800) {
    //Store vars
    this->own_internet_protocol_address = own_internet_protocol_address;
    this->default_gateway_internet_protocol_address = default_gateway_internet_protocol_address;
    this->subnet_mask = subnet_mask;
    this->error_messages = error_messages;
}

References default_gateway_internet_protocol_address, error_messages, own_internet_protocol_address, and subnet_mask.

Member Function Documentation

◆ checksum()

uint16_t InternetProtocolHandler::checksum	(	const uint16_t *	data,
		uint32_t	length_in_bytes
	)

static

Creates a checksum for the given data.

Parameters

data	The data to create a checksum for.
length_in_bytes	The length of the data in bytes.

Returns: The checksum.

Definition at line 249 of file ipv4.cpp.

                                                                                         {
 
    uint32_t temp = 0;                                                                             //Init sum
 
    for(uint32_t i = 0; i < length_in_bytes /
                            2; i++)                                                       //Loop through data (/2 bc bytes)
        temp += ((data[i] & 0xFF00) >> 8) |
                ((data[i] & 0x00FF) << 8);                             //Add data to sum in big endian
 
    if(length_in_bytes %
       2)                                                                          //If there is an odd number of bytes
        temp += ((uint16_t) ((char*) data)[length_in_bytes - 1])
        << 8;                                   //Add the last byte to the sum
 
    while(temp &
          0xFFFF0000)                                                                       //While there is a carry
        temp = (temp & 0xFFFF) +
               (temp >> 16);                                                     //Add the carry to the sum
 
    return ((~temp & 0xFF00) >> 8) | ((~temp & 0x00FF) << 8);
}

Referenced by handle_ethernetframe_payload(), MaxOS::net::InternetControlMessageProtocol::handle_internet_protocol_payload(), MaxOS::net::InternetControlMessageProtocol::request_echo_reply(), send_internet_protocol_packet(), and MaxOS::net::TransmissionControlProtocolHandler::send_transmission_control_protocol_packet().

◆ connect_ipv_4_payload_handler()

void InternetProtocolHandler::connect_ipv_4_payload_handler ( IPV4PayloadHandler * ipv_4_payload_handler )

Connects an IP protocol payload handler.

Parameters

ipv_4_payload_handler The payload handler to connect.

Definition at line 363 of file ipv4.cpp.

                                                                                                     {
    ipv_4_payload_handlers.insert(ipv_4_payload_handler->ip_protocol, ipv_4_payload_handler);
}

References ipv_4_payload_handlers.

Referenced by MaxOS::net::IPV4PayloadHandler::IPV4PayloadHandler().

◆ create_internet_protocol_address()

InternetProtocolAddress InternetProtocolHandler::create_internet_protocol_address	(	uint8_t	digit1,
		uint8_t	digit2,
		uint8_t	digit3,
		uint8_t	digit4
	)

static

Creates an IP address from four digits.

Parameters

digit1	The first digit.
digit2	The second digit.
digit3	The third digit.
digit4	The fourth digit.

Returns: The created IP address.

Definition at line 292 of file ipv4.cpp.

                                                                                                                                                {
    InternetProtocolAddress result = digit4;
    result = (result << 8) | digit3;
    result = (result << 8) | digit2;
    result = (result << 8) | digit1;
    return result;
}

Referenced by create_subnet_mask(), and parse().

◆ create_subnet_mask()

SubnetMask InternetProtocolHandler::create_subnet_mask	(	uint8_t	digit1,
		uint8_t	digit2,
		uint8_t	digit3,
		uint8_t	digit4
	)

static

Creates a subnet mask from four digits.

Parameters

digit1	The first digit.
digit2	The second digit.
digit3	The third digit.
digit4	The fourth digit.

Returns: The created subnet mask.

Definition at line 336 of file ipv4.cpp.

                                                                                                                     {
    return (SubnetMask) create_internet_protocol_address(digit1, digit2, digit3, digit4);
}

References create_internet_protocol_address().

◆ get_internet_protocol_address()

InternetProtocolAddress InternetProtocolHandler::get_internet_protocol_address ( ) const

Gets the IP address of this device.

Returns: The IP address.

Definition at line 345 of file ipv4.cpp.

                                                                                     {
    return own_internet_protocol_address;
}

References own_internet_protocol_address.

Referenced by MaxOS::net::TransmissionControlProtocolHandler::connect(), MaxOS::net::UserDatagramProtocolHandler::connect(), MaxOS::net::AddressResolutionProtocol::handle_ethernetframe_payload(), handle_ethernetframe_payload(), MaxOS::net::TransmissionControlProtocolHandler::listen(), MaxOS::net::UserDatagramProtocolHandler::listen(), MaxOS::net::AddressResolutionProtocol::request_mac_address(), and send_internet_protocol_packet().

◆ get_media_access_control_address()

MediaAccessControlAddress InternetProtocolHandler::get_media_access_control_address ( )

Gets the MAC address of this device.

Returns: The MAC address.

Definition at line 354 of file ipv4.cpp.

                                                                                    {
    return frame_handler->get_mac();
}

References MaxOS::net::EthernetFramePayloadHandler::frame_handler, and MaxOS::net::EthernetFrameHandler::get_mac().

Referenced by MaxOS::net::AddressResolutionProtocol::handle_ethernetframe_payload().

◆ handle_ethernetframe_payload()

bool InternetProtocolHandler::handle_ethernetframe_payload	(	uint8_t *	ethernetframe_payload,
		uint32_t	size
	)

overridevirtual

Called when an IP packet is received.

Parameters

ethernetframe_payload	The payload of the IP packet.
size	The size of the IP packet.

Returns: True if the packet is to be sent back, false otherwise.

Todo:: Set the identifier when sending packets back

Reimplemented from MaxOS::net::EthernetFramePayloadHandler.

Definition at line 130 of file ipv4.cpp.

                                                                                                        {
 
    error_messages->write("IP: Handling packet\n");
 
    //Check if the size is big enough to contain an ethernet frame
    if(size < sizeof(IPV4Header))
        return false;
 
    //Convert to struct for easier use
    auto* ip_message = (IPV4Header*) ethernetframe_payload;
    bool send_back = false;
 
    //Only handle if it is for this device
    if(ip_message->destination_ip == get_internet_protocol_address()) {
        uint32_t length = ip_message->total_length;                          //Get length of the message
        if(length >
           size)                                               //Check if the length is bigger than the size of the message
            length = size;                                              //If so, set length to size (this stops heartbleed attacks as it will not read past the end of the message, which the attacker could have filled with data)
 
        // Get the handler for the protocol
        Map<uint8_t, IPV4PayloadHandler*>::iterator handler_iterator = ipv_4_payload_handlers.find(ip_message->protocol);
        if(handler_iterator != ipv_4_payload_handlers.end()) {
            IPV4PayloadHandler* handler = handler_iterator->second;
            if(handler != nullptr) {
                send_back = handler->handle_internet_protocol_payload(ip_message->source_ip, ip_message->destination_ip,
                                                                      ethernetframe_payload + sizeof(IPV4Header),
                                                                      length - sizeof(IPV4Header));
            }
        }
 
 
    }
 
    //If the data is to be sent back again
    if(send_back) {
 
        //Swap source and destination
        uint32_t temp = ip_message->destination_ip;                                                                                     //Store destination IP
        ip_message->destination_ip = ip_message->source_ip;                                                                                //Set destination IP to source IP
        ip_message->source_ip = temp;                                                                                              //Set source IP to destination IP
 
        ip_message->time_to_live = 0x40;                                                                                         //Reset TTL
        ip_message->checksum = checksum((uint16_t*) ip_message, 4 *
                                                                ip_message->header_length);                  //Reset checksum as the source and destination IP have changed so has the time to live and therefore there is a different header
 
    }
 
    error_messages->write("IP: Handled packet\n");
    return send_back;
}

References checksum(), error_messages, get_internet_protocol_address(), ipv_4_payload_handlers, and MaxOS::common::OutputStream::write().

◆ parse()

InternetProtocolAddress InternetProtocolHandler::parse ( string address )

static

Parses a string representation of an IP address.

Parameters

address The string representation of the IP address.

Returns: The parsed IP address.

Definition at line 306 of file ipv4.cpp.

                                                                     {
    uint8_t digits[4];
 
    uint8_t current_digit = 0;
    for(unsigned char& digit : digits)
        digit = 0;
 
    for(size_t i = 0; i < address.length(); i++) {
        if(address[i] == '.') {
            current_digit++;
            continue;
        }
 
        digits[current_digit] *= 10;
        digits[current_digit] += address[i] - '0';
    }
 
    return create_internet_protocol_address(digits[0], digits[1], digits[2], digits[3]);
}

References create_internet_protocol_address().

◆ register_ipv_4_address_resolver()

void InternetProtocolHandler::register_ipv_4_address_resolver ( IPV4AddressResolver * ipv4_resolver )

protected

Registers an IP address resolver.

Parameters

ipv4_resolver The resolver to register.

Definition at line 276 of file ipv4.cpp.

                                                                                                {
 
    this->resolver = ipv4_resolver;
 
}

References resolver.

Referenced by MaxOS::net::IPV4AddressResolver::IPV4AddressResolver().

◆ send_internet_protocol_packet()

void InternetProtocolHandler::send_internet_protocol_packet	(	uint32_t	dst_ip_be,
		uint8_t	protocol,
		const uint8_t *	data,
		uint32_t	size
	)

Sends an IP packet.

Parameters

dst_ip_be	The destination IP address.
protocol	The protocol of the IP packet.
data	The payload of the IP packet.
size	The size of the IP packet.

Definition at line 190 of file ipv4.cpp.

                                                                                                                                    {
 
    auto* buffer = (uint8_t*) MemoryManager::kmalloc(
    sizeof(IPV4Header) + size);                           //Allocate memory for the message
    auto* message = (IPV4Header*) buffer;                                                                            //Convert to struct for easier use
 
    message->version = 4;                                                                                                                           //Set version
    message->header_length = sizeof(IPV4Header) /
                             4;                                                                                     //Set header length
    message->type_of_service = 0;                                                                                                                     //Set type of service (not private)
 
    message->total_length = size +
                            sizeof(IPV4Header);                                                                                 //Set total length
    message->total_length = ((message->total_length & 0xFF00)
    >> 8)                                                                                 // Convert to big endian (Swap bytes)
                            | ((message->total_length & 0x00FF)
    << 8);                                                                              // Convert to big endian (Swap bytes)
 
    message->identifier = 0x100;                                                                                                                    //Set identification TODO: do properly
    message->flags_and_offset = 0x0040;                                                                                                               //Set flags/offset, 0x40 because we are not fragmenting (TODO: doesnt work for packets bigger than 1500 bytes)
 
    message->time_to_live = 0x40;                                                                                                                     //Set time to live
    message->protocol = protocol;                                                                                                                   //Set protocol
 
    message->destination_ip = dst_ip_be;                                                                                                                      //Set destination IP
    message->source_ip = get_internet_protocol_address();                                                                                                  //Set source IP
 
    message->checksum = 0;                                                                                                                          //Set checksum to 0, init with 0 as checksum funct will also add this value
    message->checksum = checksum((uint16_t*) message,
                                 sizeof(IPV4Header));                                             //Calculate checksum
 
    //Copy data
    uint8_t* data_buffer = buffer +
                           sizeof(IPV4Header);                                                                                  //Get pointer to the data
    for(uint32_t i = 0; i <
                        size; i++)                                                                                                                            //Loop through data
        data_buffer[i] = data[i];                                                                                                                             //Copy data
 
    //Check if the destination is on the same subnet, The if condition determines if the destination device is on the same Local network as the source device . and if they are not on the same local network then we resolve the ip address of the gateway .
    InternetProtocolAddress route = dst_ip_be;                                                                                                                               //Set route to destination IP by default
    if((dst_ip_be & subnet_mask) != (own_internet_protocol_address &
                                     subnet_mask))                                                                                             //Check if the destination is on the same subnet
        route = default_gateway_internet_protocol_address;                                                                                                                                   //If not, set route to gateway IP
    //Print debug info
    uint32_t mac = resolver->resolve(route);
 
    //Send message
    frame_handler->send_ethernet_frame(mac, this->handled_type, buffer, size + sizeof(IPV4Header));      //Send message
    MemoryManager::kfree(
    buffer);                                                                                                 //Free memory
}

References checksum(), default_gateway_internet_protocol_address, MaxOS::net::EthernetFramePayloadHandler::frame_handler, get_internet_protocol_address(), MaxOS::net::EthernetFramePayloadHandler::handled_type, MaxOS::memory::MemoryManager::kfree(), MaxOS::memory::MemoryManager::kmalloc(), own_internet_protocol_address, MaxOS::net::IPV4AddressResolver::resolve(), resolver, MaxOS::net::EthernetFrameHandler::send_ethernet_frame(), and subnet_mask.

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

Friends And Related Symbol Documentation

◆ IPV4AddressResolver

friend class IPV4AddressResolver

friend

Definition at line 87 of file ipv4.h.

Member Data Documentation

◆ default_gateway_internet_protocol_address

InternetProtocolAddress MaxOS::net::InternetProtocolHandler::default_gateway_internet_protocol_address

protected

The IP address of the default gateway.

Definition at line 97 of file ipv4.h.

Referenced by InternetProtocolHandler(), and send_internet_protocol_packet().

◆ error_messages

common::OutputStream* MaxOS::net::InternetProtocolHandler::error_messages

protected

Stream to output error messages to.

Definition at line 94 of file ipv4.h.

Referenced by handle_ethernetframe_payload(), and InternetProtocolHandler().

◆ ipv_4_payload_handlers

common::Map<uint8_t, IPV4PayloadHandler*> MaxOS::net::InternetProtocolHandler::ipv_4_payload_handlers

protected

Map of IP protocol numbers to their payload handlers.

Definition at line 91 of file ipv4.h.

Referenced by connect_ipv_4_payload_handler(), and handle_ethernetframe_payload().

◆ own_internet_protocol_address

InternetProtocolAddress MaxOS::net::InternetProtocolHandler::own_internet_protocol_address

protected

The IP address of this device.

Definition at line 96 of file ipv4.h.

Referenced by get_internet_protocol_address(), InternetProtocolHandler(), and send_internet_protocol_packet().

◆ resolver

IPV4AddressResolver* MaxOS::net::InternetProtocolHandler::resolver = nullptr

protected

The IP address resolver.

Definition at line 93 of file ipv4.h.

Referenced by register_ipv_4_address_resolver(), and send_internet_protocol_packet().

◆ subnet_mask

SubnetMask MaxOS::net::InternetProtocolHandler::subnet_mask

protected

The subnet mask.

Definition at line 98 of file ipv4.h.

Referenced by InternetProtocolHandler(), and send_internet_protocol_packet().

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

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

Public Member Functions

Static Public Member Functions

Protected Member Functions

Protected Attributes

Friends

Detailed Description

Constructor & Destructor Documentation

◆ InternetProtocolHandler()

Member Function Documentation

◆ checksum()

◆ connect_ipv_4_payload_handler()

◆ create_internet_protocol_address()

◆ create_subnet_mask()

◆ get_internet_protocol_address()

◆ get_media_access_control_address()

◆ handle_ethernetframe_payload()

◆ parse()

◆ register_ipv_4_address_resolver()

◆ send_internet_protocol_packet()

Friends And Related Symbol Documentation

◆ IPV4AddressResolver

Member Data Documentation

◆ default_gateway_internet_protocol_address

◆ error_messages

◆ ipv_4_payload_handlers

◆ own_internet_protocol_address

◆ resolver

◆ subnet_mask