MaxOS::net::AddressResolutionProtocol Class Reference

Handles ARP requests and replies. More...

#include <arp.h>

Inheritance diagram for MaxOS::net::AddressResolutionProtocol:

Public Member Functions
	AddressResolutionProtocol (EthernetFrameHandler *ethernet_frame_handler, InternetProtocolHandler *internet_protocol_handler, common::OutputStream *error_messages)
	Constructs an AddressResolutionProtocol handler.
bool	handle_ethernetframe_payload (uint8_t *etherframe_payload, uint32_t size) final
	Called when an ARP packet is received.
void	request_mac_address (InternetProtocolAddress address)
	Request the MAC address of a given IP address.
drivers::ethernet::MediaAccessControlAddress	resolve (InternetProtocolAddress address) final
	Get the MAC address from an IP via ARP.
void	store (InternetProtocolAddress internet_protocol_address, drivers::ethernet::MediaAccessControlAddress media_access_control_address) final
	store a mapping of an IP address to a MAC address.
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
Public Member Functions inherited from MaxOS::net::IPV4AddressResolver
	IPV4AddressResolver (InternetProtocolHandler *internet_protocol_handler)
	Construct a new IPV4 Address Resolver object and register it with the Internet Protocol Handler.

Additional Inherited Members
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.

Detailed Description

Handles ARP requests and replies.

Definition at line 47 of file arp.h.

Constructor & Destructor Documentation

AddressResolutionProtocol()

net::AddressResolutionProtocol::AddressResolutionProtocol	(	EthernetFrameHandler *	ethernet_frame_handler,
		InternetProtocolHandler *	internet_protocol_handler,
		common::OutputStream *	error_messages
	)

Constructs an AddressResolutionProtocol handler.

Parameters

ethernet_frame_handler	The Ethernet frame handler to use.
internet_protocol_handler	The Internet protocol handler to use.
error_messages	The output stream to use for error messages.

Definition at line 25 of file arp.cpp.

        : EthernetFramePayloadHandler(ethernet_frame_handler, 0x0806),
        IPV4AddressResolver(internet_protocol_handler) {
    this->internet_protocol_handler = internet_protocol_handler;
    this->error_messages = error_messages;
}

Member Function Documentation

handle_ethernetframe_payload()

bool AddressResolutionProtocol::handle_ethernetframe_payload ( uint8_t *  ethernetframePayload, uint32_t  size  )

finalvirtual

Called when an ARP packet is received.

Parameters

ethernetframePayload	The payload of the ARP packet.
size	The size of the ARP packet.

Returns

True if the device should send a response, false otherwise.

Reimplemented from MaxOS::net::EthernetFramePayloadHandler.

Definition at line 41 of file arp.cpp.

                                                                                                         {
 
    //Check if the size is correct
    if (size < sizeof(ARPMessage))
        return false;
 
    //Convert the payload to an ARP message
    auto* arp_message = (ARPMessage*) ethernetframePayload;
 
    //Check if the message hardware type is Ethernet (BigEndian)
    if (arp_message->hardware_type == 0x100) {
 
        if (arp_message->protocol == 0x0008             //Check if the protocol is IPv4 (BigEndian)
            && arp_message->hardware_address_size == 6
            && arp_message->protocol_address_size == 4
            && arp_message->dst_ip == internet_protocol_handler->get_internet_protocol_address()) {
 
            switch (arp_message->command) {
                //Request
                case 0x0100:
                    arp_message->command = 0x0200;                                                                         //Set the command to reply
                    arp_message->dst_mac = arp_message->src_mac;                                                            //Set the destination MAC to the source MAC
                    arp_message->dst_ip = arp_message->src_ip;                                                              //Set the destination IP to the source IP
                    arp_message->src_mac = internet_protocol_handler->get_media_access_control_address();                      //Set the source MAC to this MAC
                    arp_message->src_ip = internet_protocol_handler->get_internet_protocol_address();                         //Set the source IP to this IP
                    return true;
 
                    //Response
                case 0x0200:
                    address_cache.insert((InternetProtocolAddress) arp_message->src_ip,
                                         (MediaAccessControlAddress) arp_message->src_mac);     //Insert the MAC address into the cache
                    break;
 
                default:
                    break;
 
            }
 
        }
 
    }
 
    //By default, don't send anything back
    return false;
 
 
}

References MaxOS::net::InternetProtocolHandler::get_internet_protocol_address(), MaxOS::net::InternetProtocolHandler::get_media_access_control_address(), and MaxOS::common::Map< Key, Value >::insert().

request_mac_address()

void AddressResolutionProtocol::request_mac_address

(

InternetProtocolAddress

address

)

Request the MAC address of a given IP address.

Parameters

address

The IP address in BigEndian.

Definition at line 95 of file arp.cpp.

                                                                                   {
 
    //When a MAC address is requested, instantiate a new ARP message block on the stack
    ARPMessage arp_message = { };
 
    //Set the message's values
    arp_message.hardware_type = 0x0100;                                                   //Ethernet, encoded in BigEndian
    arp_message.protocol = 0x0008;                                                       //IPv4, encoded in BigEndian
    arp_message.hardware_address_size = 6;                                                 //MAC address size
    arp_message.protocol_address_size = 4;                                                 //IPv4 address size
    arp_message.command = 0x0100;                                                        //Request, encoded in BigEndian
 
    //Set the message's source and destination
    arp_message.src_mac = frame_handler->get_mac();                                       //Set the source MAC address to the backend's MAC address
    arp_message.src_ip = internet_protocol_handler->get_internet_protocol_address();        //Set the source IP address to the backend's IP address
    arp_message.dst_mac = 0xFFFFFFFFFFFF;                                                 //Set the destination MAC address to broadcast
    arp_message.dst_ip = address;                                                           //Set the destination IP address to the requested IP address
 
    //Send the message
    this->send(arp_message.dst_mac, (uint8_t*) &arp_message, sizeof(ARPMessage));
 
 
}

References MaxOS::net::ARPMessage::dst_mac, MaxOS::net::EthernetFramePayloadHandler::frame_handler, MaxOS::net::InternetProtocolHandler::get_internet_protocol_address(), MaxOS::net::EthernetFrameHandler::get_mac(), and MaxOS::net::EthernetFramePayloadHandler::send().

Referenced by resolve().

resolve()

MediaAccessControlAddress AddressResolutionProtocol::resolve ( InternetProtocolAddress  address )

finalvirtual

Get the MAC address from an IP via ARP.

Parameters

address

The IP address to get the MAC address from.

Returns

The MAC address of the IP address.

Todo:

Should have a timeout in case the address cannot be resolved and avoid infinite loops

Reimplemented from MaxOS::net::IPV4AddressResolver.

Definition at line 128 of file arp.cpp.

                                                                                            {
 
    volatile Map<InternetProtocolAddress, MediaAccessControlAddress>::iterator cache_iterator = address_cache.find(
            address); //Check if the MAC address is in the cache
 
    //If not, request it
    if (address_cache.end() == cache_iterator) {
        request_mac_address(address);
    }
 
    //This isn't safe because the MAC address might not be in the cache yet or the machine may not be connected to the network (possible infinite loop) //TODO: TIMEOUT
    while (cache_iterator == address_cache.end()) {                         //Wait until the MAC address is found
        cache_iterator = address_cache.find(address);
    }
 
    //Return the MAC address
 
    return cache_iterator->second;
 
}

References MaxOS::common::Map< Key, Value >::end(), MaxOS::common::Map< Key, Value >::find(), and request_mac_address().

store()

void AddressResolutionProtocol::store ( InternetProtocolAddress  internet_protocol_address, drivers::ethernet::MediaAccessControlAddress  media_access_control_address  )

finalvirtual

store a mapping of an IP address to a MAC address.

Parameters

internet_protocol_address	The IP address.
media_access_control_address	The MAC address.

Reimplemented from MaxOS::net::IPV4AddressResolver.

Definition at line 155 of file arp.cpp.

                                                                                                                                                              {
    address_cache.insert(internet_protocol_address, media_access_control_address);
}

References MaxOS::common::Map< Key, Value >::insert().

---

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

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