NetUdp.cpp

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

#include "NetUdp.hpp"
#include "NetIp.hpp"
#include "Net.hpp"
#include "NetCfg.hpp"
#include "LibEndian.hpp"
#include "NetClientDhcp.hpp"
#include "NetNbns.hpp"
#include "NetRemoteConfiguration.hpp"
#include "NetUdpSocket.hpp"

LibLinkedList<NetUdpSocket> NetUdp::sSocketList;
RtosSemaphore NetUdp::sSema(1, 1);

void NetUdp::processFrame(NetDefs::FRAME& frame, NetDefs::UDP_HEADER& header, int len) {
    swapHeader(header);

#if NET_CFG_USE_DHCP_CLIENT//
    if (header.dstPort == NetDefs::UDP_PORT_DHCP_CLIENT) {
        NetClientDhcp::processFrame(frame, *((NetDefs::DHCP_HEADER*) (((uint8_t*) &header) + sizeof(header))), len - sizeof(header));
        return;
    }
#endif//NET_CFG_USE_DHCP_CLIENT
#if NET_CFG_USE_NBNS//
    if (header.dstPort == NetDefs::UDP_PORT_NBNS) {
        NetNbns::processFrame(frame, *((NetDefs::NBNS_HEADER*) (((uint8_t*) &header) + sizeof(header))), len - sizeof(header));
        return;
    }
#endif//NET_CFG_USE_NBNS
#if NET_CFG_USE_REMOTE_CONFIGURATION//
    if (header.dstPort == NET_CFG_REMOTE_CONFIGURATION_PORT) {
        NetRemoteConfiguration::processFrame(frame, len - sizeof(header));
        return;
    }
#endif//NET_CFG_USE_REMOTE_CONFIGURATION
    NetUdpSocket* socket;
    if (header.dstPort == 0) {
        Net::freeFrame(frame);
    }
    else if ((socket = findMatchingSocket(header.dstPort)) == 0) {
        Net::freeFrame(frame);
    }
    else {
        NetDefs::IP_ADDR srcIp = frame.types.ip.ipHeader.srcAddr;
        NetDefs::UDP_PORT srcPort = header.srcPort;

        NetUdpSocket::RX_PACKET* rxPkt = (NetUdpSocket::RX_PACKET*) Net::resizeFrameLeft(frame,
                (((uint8_t*) &header + sizeof(NetDefs::UDP_HEADER) - (uint8_t*) &frame)) - sizeof(NetUdpSocket::PACKET_HEADER));
        if (!rxPkt) {
            Net::freeFrame(frame);
            return;
        }
        rxPkt->hdr.ip = srcIp;
        rxPkt->hdr.port = srcPort;
        rxPkt->hdr.dataLen = len - sizeof(NetDefs::UDP_HEADER);
        if (!socket->mRxMsgBox.give(rxPkt, 0)) {
            Net::freeFrame((NetDefs::FRAME&) rxPkt);
            return;
        }
    }
}

void NetUdp::putHeader(NetDefs::FRAME& frame, const NetDefs::MAC_ADDR& macDst, const NetDefs::IP_ADDR& dstAddr, uint16_t srcPort, uint16_t dstPort,
        int dataLen) {

    frame.types.udp.udpHeader.dstPort = dstPort;
    frame.types.udp.udpHeader.srcPort = srcPort;
    frame.types.udp.udpHeader.len = sizeof(NetDefs::UDP_HEADER) + dataLen;
    frame.types.udp.udpHeader.checkSum = 0;

    swapHeader(frame.types.udp.udpHeader);

    NetIp::putHeader(frame, macDst, dstAddr, sizeof(NetDefs::UDP_HEADER) + dataLen, NetDefs::IP_PROTOCOL_UDP);
}

void NetUdp::flush(NetDefs::FRAME& frame, int dataLen, bool discardable) {
    NetIp::flush(frame, sizeof(NetDefs::UDP_HEADER) + dataLen, discardable);
}

void NetUdp::swapHeader(NetDefs::UDP_HEADER& header) {
    header.srcPort = LibEndian::hwToBe(header.srcPort);
    header.dstPort = LibEndian::hwToBe(header.dstPort);
    header.len = LibEndian::hwToBe(header.len);
}

NetUdpSocket* NetUdp::findMatchingSocket(NetDefs::UDP_PORT port) {
    sSema.take(Rtos::TICK_INFINITE);
    for (NetUdpSocket* s = sSocketList.getFirst(); s != 0; s = s->getNext()) {
        if (s->mLocalPort == port) {
            sSema.give(Rtos::TICK_INFINITE);
            return s;
        }
    }
    sSema.give(Rtos::TICK_INFINITE);
    return 0;
}

void NetUdp::addSocket(NetUdpSocket& socket) {
    sSema.take(Rtos::TICK_INFINITE);
    sSocketList.insert(socket);
    sSema.give(Rtos::TICK_INFINITE);
}

void NetUdp::removeSocket(NetUdpSocket& socket) {
    sSema.take(Rtos::TICK_INFINITE);
    sSocketList.remove(socket);
    sSema.give(Rtos::TICK_INFINITE);
}