NetArp.cpp

//------------------------------------------------------------------------------
//This file is part of embKernel. 
//See license.txt for the full license governing this code.
//------------------------------------------------------------------------------

#include "NetArp.hpp"
#include "LibEndian.hpp"
#include "Net.hpp"

NetArp::SLOT NetArp::sSlots[NET_CFG_MAX_ARP_ENTRIES];

void NetArp::processFrame(NetDefs::FRAME& frame, NetDefs::ARP_HEADER& header) {
    swapHeader(header);

    switch (header.operation) {
    case NetDefs::ARP_OPERATION_REQ:
        if (header.dstIpAddr == Net::sConfig.ipAddr) {
            send(frame, header.srcMacAddr, header.srcIpAddr, NetDefs::ARP_OPERATION_RESP);
        }
        else {
            Net::freeFrame(frame);
        }
        break;
    case NetDefs::ARP_OPERATION_RESP: {
        SLOT* slot = getWaitingSlot(header.srcIpAddr);
        if (slot) {
            slot->macAddr = header.srcMacAddr;
            slot->status = SLOT_RESOLVED;
            slot->task->resume();
        }
        Net::freeFrame(frame);
        break;
    }
    default:
        Net::freeFrame(frame);
        break;
    }

}

bool NetArp::resolve(NetDefs::IP_ADDR ipAddr, NetDefs::MAC_ADDR& macAddr) {
    //If broadcast return broadcast MAC

    if (ipAddr == NetDefs::IP_BROADCAST) {
        macAddr = NetDefs::MAC_BROADCAST;
        return true;
    }

    if ((Net::getConfig().ipAddr.val ^ ipAddr.val) & Net::getConfig().mask.val) {
        ipAddr = Net::getConfig().gatewayIpAddr;
    }

    if (checkCache(ipAddr, macAddr)) {
        return true;
    }

    SLOT* slot = getFreeSlot();

    if (!slot) {
        return false;
    }

    NetDefs::FRAME* frame = Net::allocFrame(sizeof(NetDefs::MAC_HEADER) + sizeof(NetDefs::ARP_HEADER));
    if (!frame) {
        slot->status = SLOT_EMPTY;
        return false;
    }

    slot->ipAddr = ipAddr;
    slot->timer = TIMEOUT_SLOT_RESOLVING;
    slot->status = SLOT_RESOLVING;
    slot->task = Rtos::getCurrentTask();

    //Send the request
    send(*frame, NetDefs::MAC_BROADCAST, ipAddr, NetDefs::ARP_OPERATION_REQ);

    while (true) {
        slot->task->suspend();
        if (slot->status != SLOT_RESOLVING) {
            if (slot->status == SLOT_RESOLVED) {
                macAddr = slot->macAddr;
                slot->timer = TIMEOUT_SLOT_VALID;
                slot->status = SLOT_VALID;
                return true;
            }
            break;
        }
    }

    slot->status = SLOT_EMPTY;

    return false;
}

NetArp::SLOT* NetArp::getFreeSlot() {
    uint16_t smalestTimer = 0xFFFF;
    int oldest = -1;
    Rtos::enterCriticalSection();
    for (int i = 0; i < NET_CFG_MAX_ARP_ENTRIES; i++) {

        if (sSlots[i].status == SLOT_EMPTY) {
            sSlots[i].status = SLOT_RESERVED;
            Rtos::exitCriticalSection();
            return &sSlots[i];
        }
        if (sSlots[i].status == SLOT_VALID) {
            if (sSlots[i].timer < smalestTimer) {
                oldest = i;
            }
        }
    }
    if (oldest >= 0) {
        sSlots[oldest].status = SLOT_RESERVED;
        Rtos::exitCriticalSection();
        return &sSlots[oldest];
    }
    Rtos::exitCriticalSection();
    return 0;
}

NetArp::SLOT* NetArp::getWaitingSlot(const NetDefs::IP_ADDR ipAddr) {
    for (int i = 0; i < NET_CFG_MAX_ARP_ENTRIES; i++) {
        if ((sSlots[i].status == SLOT_RESOLVING) && (sSlots[i].ipAddr == ipAddr)) {
            return &sSlots[i];
        }
    }
    return 0;
}

bool NetArp::checkCache(const NetDefs::IP_ADDR& ipAddr, NetDefs::MAC_ADDR& macAddr) {
    for (int i = 0; i < NET_CFG_MAX_ARP_ENTRIES; i++) {
        Rtos::enterCriticalSection();
        if ((sSlots[i].status == SLOT_VALID) && (sSlots[i].ipAddr == ipAddr)) {
            macAddr = sSlots[i].macAddr;
            Rtos::exitCriticalSection();
            return true;
        }
        Rtos::exitCriticalSection();
    }
    return false;
}

//Every 100ms
void NetArp::tick() {
    for (int i = 0; i < NET_CFG_MAX_ARP_ENTRIES; i++) {
        if (--sSlots[i].timer == 0) {
            Rtos::enterCriticalSection();
            if ((sSlots[i].status == SLOT_VALID)) {
                sSlots[i].status = SLOT_EMPTY;
            }
            Rtos::exitCriticalSection();

            if ((sSlots[i].status == SLOT_RESOLVING)) {
                sSlots[i].status = SLOT_TIMEOUT;
                sSlots[i].task->resume();
            }
        }
    }
}

void NetArp::send(NetDefs::FRAME& frame, const NetDefs::MAC_ADDR& macDst, const NetDefs::IP_ADDR& ipDst, const NetDefs::ARP_OPERATION op) {
    frame.types.arp.arpHeader.hardwareType = NetDefs::ARP_HW_TYPE_ETHERNET;
    frame.types.arp.arpHeader.protocol = NetDefs::ARP_PROTOCOL_IP;
    frame.types.arp.arpHeader.macAddrLen = sizeof(NetDefs::MAC_ADDR);
    frame.types.arp.arpHeader.protocolLen = sizeof(NetDefs::IP_ADDR);

    frame.types.arp.arpHeader.operation = op;

    if (op == NetDefs::ARP_OPERATION_RESP) {
        frame.types.arp.arpHeader.dstMacAddr = macDst;
    }
    else {
        frame.types.arp.arpHeader.dstMacAddr = NetDefs::MAC_BROADCAST;
    }

    frame.types.arp.arpHeader.srcIpAddr = Net::sConfig.ipAddr;
    frame.types.arp.arpHeader.srcMacAddr = Net::sMacAddr;
    frame.types.arp.arpHeader.dstIpAddr = ipDst;

    swapHeader(frame.types.arp.arpHeader);

    Net::putHeader(frame, frame.types.arp.arpHeader.dstMacAddr, NetDefs::MAC_TYPE_ARP);
    Net::flush(frame, sizeof(NetDefs::MAC_HEADER) + sizeof(NetDefs::ARP_HEADER), true);
}

void NetArp::swapHeader(NetDefs::ARP_HEADER& header) {
    header.hardwareType = (NetDefs::ARP_HW_TYPE) LibEndian::hwToBe((uint16_t) header.hardwareType);
    header.protocol = (NetDefs::ARP_PROTOCOL) LibEndian::hwToBe((uint16_t) header.protocol);
    header.operation = (NetDefs::ARP_OPERATION) LibEndian::hwToBe((uint16_t) header.operation);
}