MaxOS::net::EthernetFrameHandler Class Reference

Handles incoming Ethernet Frames and routes them to the appropriate payload handlers. More...

#include <ethernetframe.h>

Inheritance diagram for MaxOS::net::EthernetFrameHandler:

Public Member Functions
	EthernetFrameHandler (drivers::ethernet::EthernetDriver *driver, common::OutputStream *error_messages)
	Construct a new Ether Frame Handler object.
drivers::ethernet::MediaAccessControlAddress	get_mac ()
	Get the MAC address of this device.
bool	data_received (uint8_t *data, uint32_t size) override
	Handle the received packet.
void	connect_handler (EthernetFramePayloadHandler *handler)
	connect a handler to the frame handler
void	send_ethernet_frame (uint64_t destination_mac, uint16_t frame_type, uint8_t *data, uint32_t size)
	send an packet via the backend driver
Public Member Functions inherited from MaxOS::drivers::ethernet::EthernetDriverEventHandler
	EthernetDriverEventHandler ()
	__EVENT HANDLER___
common::Event< EthernetDriverEvents > *	on_event (common::Event< EthernetDriverEvents > *event) override
	Handle an event.
virtual void	before_send (uint8_t *buffer, uint32_t size)
	Handle before send event.
virtual void	data_sent (uint8_t *buffer, uint32_t size)
	Handle data sent event.
Public Member Functions inherited from MaxOS::common::EventHandler< EthernetDriverEvents >
virtual Event< EthernetDriverEvents > *	on_event (Event< EthernetDriverEvents > *event)
	This function is called when an event is raised.

Protected Attributes
common::Map< uint16_t, EthernetFramePayloadHandler * >	frame_handlers
	The map of frame handlers by type.
drivers::ethernet::EthernetDriver *	ethernet_driver
	The driver this frame handler is using.
common::OutputStream *	error_messages
	The output stream for error messages.

Detailed Description

Handles incoming Ethernet Frames and routes them to the appropriate payload handlers.

Definition at line 76 of file ethernetframe.h.

Constructor & Destructor Documentation

EthernetFrameHandler()

EthernetFrameHandler::EthernetFrameHandler	(	drivers::ethernet::EthernetDriver *	driver,
		common::OutputStream *	error_messages
	)

Construct a new Ether Frame Handler object.

Parameters

driver	The backend ethernet driver
error_messages	The output stream for error messages

Definition at line 73 of file ethernetframe.cpp.

        : EthernetDriverEventHandler() {
 
    this->ethernet_driver = driver;
    this->error_messages = error_messages;
 
    driver->connect_event_handler(this);
 
}

References error_messages, and ethernet_driver.

Member Function Documentation

connect_handler()

void EthernetFrameHandler::connect_handler

(

EthernetFramePayloadHandler *

handler

)

connect a handler to the frame handler

Parameters

handler

The handler to connect

Definition at line 164 of file ethernetframe.cpp.

                                                                               {
 
    // Convert the protocol type to big endian
    uint16_t frame_type_be = ((handler->handled_type >> 8) & 0xFF) | ((handler->handled_type << 8) & 0xFF00);
 
    // Add the handler to the list
    frame_handlers.insert(frame_type_be, handler);
 
}

References frame_handlers.

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

data_received()

bool EthernetFrameHandler::data_received ( uint8_t *  buffer, uint32_t  size  )

overridevirtual

Handle the received packet.

Parameters

buffer	the buffer with the received data
size	the size of the received data

Returns

True if the data is to be sent back, false otherwise

Todo:

Future debugging me: the override is not being called in derived classes

Reimplemented from MaxOS::drivers::ethernet::EthernetDriverEventHandler.

Definition at line 104 of file ethernetframe.cpp.

                                                                       {
 
    error_messages->write("EFH: Data received\n");
 
 
    //Check if the size is big enough to contain an ethernet frame
    if(size < sizeof(EthernetFrameHeader))
        return false;
 
    //Convert to struct for easier use
    auto* frame = (EthernetFrameHeader*) buffer;
    bool send_back = false;
 
    //Only handle if it is for this device
    if(frame->destination_mac == 0xFFFFFFFFFFFF                                          //If it is a broadcast
       || frame->destination_mac == ethernet_driver->get_media_access_control_address())      //If it is for this device
    {
 
        // Find the handler for the protocol
        Map<uint16_t, EthernetFramePayloadHandler*>::iterator handler_iterator = frame_handlers.find(frame->type);
 
        // If the handler is found
        if(handler_iterator != frame_handlers.end()) {
 
            //Handle the data
            error_messages->write("EFH: Handling ethernet frame payload\n");
            send_back = handler_iterator->second->handle_ethernetframe_payload(buffer + sizeof(EthernetFrameHeader),
                                                                               size - sizeof(EthernetFrameHeader));
            error_messages->write("..DONE\n");
 
        } else {
 
            //If the handler is not found, print an error message
            error_messages->write("EFH: Unhandled ethernet frame type 0x");
            error_messages->write_hex(frame->type);
            error_messages->write("\n");
 
        }
    }
 
    //If the data is to be sent back again
    if(send_back) {
 
        error_messages->write("EFH: Sending back\n");
 
        frame->destination_mac = frame->source_mac;                             //Set the new destination to be the device the data was received from
        frame->source_mac = ethernet_driver->get_media_access_control_address();      //Set the new source to be this device's MAC address
 
    }
 
    //Return if the data is to be sent back
    return send_back;
 
}

References error_messages, ethernet_driver, frame_handlers, MaxOS::drivers::ethernet::EthernetDriver::get_media_access_control_address(), MaxOS::common::OutputStream::write(), and MaxOS::common::OutputStream::write_hex().

get_mac()

drivers::ethernet::MediaAccessControlAddress EthernetFrameHandler::get_mac

(

)

Get the MAC address of this device.

Returns

MediaAccessControlAddress The MAC address

Definition at line 90 of file ethernetframe.cpp.

                                                                       {
    return ethernet_driver->get_media_access_control_address();
}

References ethernet_driver, and MaxOS::drivers::ethernet::EthernetDriver::get_media_access_control_address().

Referenced by MaxOS::net::InternetProtocolHandler::get_media_access_control_address(), and MaxOS::net::AddressResolutionProtocol::request_mac_address().

send_ethernet_frame()

void EthernetFrameHandler::send_ethernet_frame	(	uint64_t	destination_mac,
		uint16_t	frame_type,
		uint8_t *	data,
		uint32_t	size
	)

send an packet via the backend driver

Parameters

destination_mac	the destination MAC address
frame_type	the type of the protocol
data	the data to send
size	the size of the payload

Definition at line 182 of file ethernetframe.cpp.

                                                                                                                          {
 
    error_messages->write("EFH: Sending frame...");
 
    //Allocate memory for the buffer
    auto* buffer = (uint8_t*) MemoryManager::kmalloc(size + sizeof(EthernetFrameHeader));
    auto* frame = (EthernetFrameHeader*) buffer;
 
    //Put data in the header
    frame->destination_mac = destination_mac;
    frame->source_mac = ethernet_driver->get_media_access_control_address();
    frame->type = (frame_type >> 8) | (frame_type << 8);                        //Convert to big endian
 
    //Copy the data
    for(uint8_t* src = data + size - 1, * dst = buffer + sizeof(EthernetFrameHeader) + size - 1; src >= data; --src, --dst)
        *dst = *src;
 
    //Send the data
    ethernet_driver->send(buffer, size + sizeof(EthernetFrameHeader));
 
    error_messages->write("Done\n");
 
 
    //Free the buffer
    MemoryManager::kfree(buffer);
}

References error_messages, ethernet_driver, MaxOS::drivers::ethernet::EthernetDriver::get_media_access_control_address(), MaxOS::memory::MemoryManager::kfree(), MaxOS::memory::MemoryManager::kmalloc(), MaxOS::drivers::ethernet::EthernetDriver::send(), and MaxOS::common::OutputStream::write().

Referenced by MaxOS::net::EthernetFramePayloadHandler::send(), and MaxOS::net::InternetProtocolHandler::send_internet_protocol_packet().

Member Data Documentation

error_messages

common::OutputStream* MaxOS::net::EthernetFrameHandler::error_messages

protected

The output stream for error messages.

Definition at line 82 of file ethernetframe.h.

Referenced by data_received(), EthernetFrameHandler(), and send_ethernet_frame().

ethernet_driver

drivers::ethernet::EthernetDriver* MaxOS::net::EthernetFrameHandler::ethernet_driver

protected

The driver this frame handler is using.

Definition at line 81 of file ethernetframe.h.

Referenced by data_received(), EthernetFrameHandler(), get_mac(), and send_ethernet_frame().

frame_handlers

common::Map<uint16_t, EthernetFramePayloadHandler*> MaxOS::net::EthernetFrameHandler::frame_handlers

protected

The map of frame handlers by type.

Definition at line 79 of file ethernetframe.h.

Referenced by connect_handler(), and data_received().

---

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

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