/****************************************************************
 * File name	: Udp.c						*
 * By 			: hugang, hgx2000@mail.china.com	*
 ****************************************************************/

#include <string.h>
#include <ctype.h>
#include "Armnet.h"
#include "../inc/44blib.h"

extern NODE locnode;

/********************************************************************************************************
 * Return UDP data length (-1 if no data), 0 if not UDP 												*
 ********************************************************************************************************/
short IsUdp(IPKT *ip, short len)
{
    UDPKT *udp;
    unsigned short sum;
    short dlen=0;
                                        							// Check protocol & minimum length
    if (ip->i.pcol==PUDP && len>=sizeof(UDPHDR))
    {
        udp = (UDPKT *)ip;              							// Do checksum
        sum = CheckUdp(udp, swapl(READ_PACKED(ip->i.sip)), swapl(READ_PACKED(ip->i.dip)), len);
        if (!udp->u.check || sum==0xffff)
        {                               							// If zero or correct..
            SwapUdp(udp);              							// Do byte-swaps
            len -= sizeof(UDPHDR);      							// Subtract header len
            dlen = len>0 ? len : -1;    							// Return -1 if data len=0
        }
    }
    return(dlen);
}


/********************************************************************************************************
 * Make a UDP datagram given the source & destination, data len 										*
 ********************************************************************************************************/
short MakeUdp(ETHERFRAME *efp, NODE *srcep, NODE *destp, unsigned short dlen)
{
    UDPKT *udp;
    short ulen, ilen;

    udp = (UDPKT *)(efp->edata);
    udp->u.sport = srcep->port;          							// Set ports
    udp->u.dport = destp->port;
    udp->u.len = ulen = dlen + sizeof(UDPHDR);
    udp->u.check = 0;
    SwapUdp(udp);                      							// Byte-swap
    ilen = MakeIp(efp, srcep, destp, PUDP, (unsigned short)(ulen));
    udp->u.check = ~CheckUdp(udp, swapl(srcep->ip), swapl(destp->ip), ulen);
    if (udp->u.check == 0)              							// Change sum of 0 to FFFF
        udp->u.check = 0xffff;
    return(ilen);                       							// Return IP length
}


/********************************************************************************************************
 * Return UDP checksum, given UDP (header + data) length.												*
 * The values must be in network byte-order 															*
 ********************************************************************************************************/
unsigned short CheckUdp(UDPKT *udp, unsigned int sip, unsigned int dip, short ulen)
{
    PHDR tph;
    unsigned int sum;

    sum = csum((unsigned char *)&udp->u, (unsigned short)ulen);  	// Checksum UDP segment
    tph.len = swapw((unsigned short)ulen);                			// Make pseudo-header
    tph.srce = sip;
    tph.dest = dip;
    tph.z = 0;
    tph.pcol = udp->i.pcol;
    sum += csum((void *)&tph, sizeof(tph));             					// Checksum pseudo-header
    return((unsigned short)(sum + (sum >> 16)));          			// Return total plus carry
}


/********************************************************************************************************
 * Swap byte order of ints in UDP header 																*
 ********************************************************************************************************/
void SwapUdp(UDPKT *udp)
{
    udp->u.sport = swapw(udp->u.sport);
    udp->u.dport = swapw(udp->u.dport);
    udp->u.len = swapw(udp->u.len);
}


/********************************************************************************************************
 * Get the frame driver type, source port, IP and Ethernet addrs 										*
 ********************************************************************************************************/
void GetUdpSrce(ETHERFRAME *efp, NODE *np)
{
    UDPKT *udp;

    memset(np, 0, sizeof(NODE));        							// Clear unused fields
    GetIpSrce(efp, np);                							// Get dtype, srce IP and Ether addrs
    udp = (UDPKT *)(efp->edata);
    np->port = udp->u.sport;            							// Get source port
}


/********************************************************************************************************
 * Get the frame driver type, destination port, IP and Ethernet addrs 									*
 ********************************************************************************************************/
void GetUdpDest(ETHERFRAME *efp, NODE *np)
{
    UDPKT *udp;

    memset(np, 0, sizeof(NODE));        							// Clear unused fields
    GetIpDest(efp, np);                							// Get dtype, dest IP and Ether addrs
    udp = (UDPKT *)(efp->edata);
    np->port = udp->u.dport;            							// Get dest port
}


/********************************************************************************************************
 * UDP handler 																							*
 ********************************************************************************************************/
void  UdpRcvPacket(ETHERFRAME *efp)
{
	NODE desnode;

	GetUdpDest(efp, &desnode);
	if((desnode.port == TFTPORT) && (desnode.ip == locnode.ip))
	{
		DEBUGF(TFTP_DEBUG,("Get TFPT\n"));
		TftpRcvPacket(efp);
	}

}