NetIp.cpp

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

#include "NetIp.hpp"
#include "Net.hpp"
#include "NetIcmp.hpp"
#include "NetUdp.hpp"
#include "NetTcp.hpp"
#include "LibEndian.hpp"
#include "NetMac.hpp"
#include "NetChecksum.hpp"

void NetIp::processFrame(NetDefs::FRAME& frame, NetDefs::IP_HEADER& header) {
    swapHeader(header);

    if (checkDstAddress(header.dstAddr)) {

        //Calculate the sizes
        int headerLen = (int) ((header.headerLen) << 2);
        int optionLen = headerLen - sizeof(NetDefs::IP_HEADER);
        int len = header.totalLen - headerLen;

        switch (header.protocol) {
        case NetDefs::IP_PROTOCOL_ICMP:
            NetIcmp::processFrame(frame, *((NetDefs::ICMP_HEADER*) (((uint8_t*) &header) + headerLen + optionLen)), len);
            break;
        case NetDefs::IP_PROTOCOL_UDP:
            NetUdp::processFrame(frame, *((NetDefs::UDP_HEADER*) (((uint8_t*) &header) + headerLen + optionLen)), len);
            break;
        case NetDefs::IP_PROTOCOL_TCP:
            NetTcp::processFrame(frame, *((NetDefs::TCP_HEADER*) (((uint8_t*) &header) + headerLen + optionLen)), len);
            break;
        default:
            Net::freeFrame(frame);
            break;
        }
    }
    else {
        Net::freeFrame(frame);
    }

}

bool NetIp::checkDstAddress(NetDefs::IP_ADDR& address) {
    //Broadcast
    if (address == NetDefs::IP_BROADCAST) {
        return true;
    }
    //Multicast
    if ((address.val ^ (~Net::sConfig.mask.val)) == (Net::sConfig.ipAddr.val & Net::sConfig.mask.val)) {
        return true;
    }
    //Unicast
    if (address == Net::sConfig.ipAddr) {
        return true;
    }

    return false;
}

void NetIp::putHeader(NetDefs::FRAME& frame, const NetDefs::MAC_ADDR& macDst, const NetDefs::IP_ADDR& ipDst, int dataLen, uint8_t protocol) {
    static int identification = 0x0000;

    frame.types.ip.ipHeader.version = 4;
    frame.types.ip.ipHeader.headerLen = 5;
    frame.types.ip.ipHeader.typeOfService = 0x00;
    frame.types.ip.ipHeader.totalLen = sizeof(NetDefs::IP_HEADER) + dataLen;
    frame.types.ip.ipHeader.identification = ++identification;
    frame.types.ip.ipHeader.fragmentInfo = 0;
    frame.types.ip.ipHeader.timeToLive = 0x80;
    frame.types.ip.ipHeader.protocol = (NetDefs::IP_PROTOCOL) protocol;
    frame.types.ip.ipHeader.headerChecksum = 0;
    frame.types.ip.ipHeader.dstAddr = ipDst;
    frame.types.ip.ipHeader.srcAddr = Net::sConfig.ipAddr;

    swapHeader(frame.types.ip.ipHeader);

    frame.types.ip.ipHeader.headerChecksum = NetChecksum::finalizeCheckSum(NetChecksum::calcPartialChecksum((uint8_t*) &frame.types.ip.ipHeader, sizeof(NetDefs::IP_HEADER)));

    Net::putHeader(frame, macDst, NetDefs::MAC_TYPE_IP);
}

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

void NetIp::swapHeader(NetDefs::IP_HEADER& header) {
    header.totalLen = LibEndian::hwToBe(header.totalLen);
    header.identification = LibEndian::hwToBe(header.identification);
    header.headerChecksum = LibEndian::hwToBe(header.headerChecksum);
}