File content as of revision 36:900e24b27bfb:

#include  "mbed.h"
#include   "log.h"
#include   "net.h"
#include   "eth.h"
#include  "dhcp.h"
#include    "ns.h"
#include    "ip.h"
#include   "ip6.h"
#include "slaac.h"
#include   "tcp.h"
#include   "udp.h"

#define DEBUG false

static uint16_t calculateChecksum(uint8_t pro, char* pSrcIp, char* pDstIp, int size, void* pPacket)
{
    __packed struct pseudo
    {
        char src[16];
        char dst[16];
        uint8_t  zer;
        uint8_t  pro;
        uint16_t len;
    } pseudo;
    
    memcpy(pseudo.src, pSrcIp, 16);
    memcpy(pseudo.dst, pDstIp, 16);
    pseudo.zer = 0;
    pseudo.pro = pro;
    pseudo.len = NetToHost16(size);

    return NetCheckSumTwo(sizeof(pseudo), &pseudo, size, pPacket);
}


static void finalisePacket(uint8_t pro, int action, void* pPacket, int size, char* pSrcIp, char* pDstIp)
{    
    if (!action) return;
    
    Ip6DestIpFromAction(action, pDstIp);
    
    Ip6Copy(pSrcIp, SlaacLinkLocalIp);
    
    switch (pro)
    {
        case TCP: TcpMakeHeader(size, pPacket); break;
        case UDP: UdpMakeHeader(size, pPacket); break;
    }
    uint16_t checksum = calculateChecksum(pro, pSrcIp, pDstIp, size, pPacket);
    
    switch (pro)
    {
        case TCP: TcpAddChecksum(pPacket, checksum); break;
        case UDP: UdpAddChecksum(pPacket, checksum); break;
    }
    
    switch (pro)
    {
        case TCP: if (DEBUG) TcpLogHeader("IPv6 packet sent", pPacket, 0); break;
        case UDP: if (DEBUG) UdpLogHeader("IPv6 packet sent", pPacket, 0); break;
    }
}

int Tcp6HandleReceivedPacket(char* pSrcIp, char* pDstIp, int *pSize, void * pPacket)
{
    uint16_t calculatedChecksum = calculateChecksum(TCP, pSrcIp, pDstIp, *pSize, pPacket);
    if (DEBUG) TcpLogHeader("IPv6 packet received", pPacket, calculatedChecksum);
    
    TcpReadHeader(pPacket, *pSize);
    
    int action = TcpHandleReceivedPacket(pSize, pPacket);
    
    Ip6Copy(pDstIp, pSrcIp);
    
    finalisePacket(TCP, action, pPacket, *pSize, pSrcIp, pDstIp);
        
    return action;
}

int Udp6HandleReceivedPacket(char* pSrcIp, char* pDstIp, int *pSize, void * pPacket)
{
    uint16_t calculatedChecksum = calculateChecksum(UDP, pSrcIp, pDstIp, *pSize, pPacket);
    if (DEBUG) UdpLogHeader("IPv6 packet received", pPacket, calculatedChecksum);
    
    UdpReadHeader(pPacket, *pSize);
    
    int action = UdpHandleReceivedPacket(pSize, pPacket);
    
    Ip6Copy(pDstIp, pSrcIp);
    
    finalisePacket(UDP, action, pPacket, *pSize, pSrcIp, pDstIp);
        
    return action;
}
int Udp6PollForPacketToSend(void* pPacket, int* pSize, char* pSrcIp, char* pDstIp)
{        
    int action = UdpPollForPacketToSend(IPV6, pSize, pPacket);
    
    finalisePacket(UDP, action, pPacket, *pSize, pSrcIp, pDstIp);
                
    return action;

}