---

udp.c

Go to the documentation of this file.

/*!     \file network/udp.c
 *      \brief UDP (User Datagram Protocol) layer.
 *      \author Andrea Righi <drizzt@inwind.it>
 *      \date Last update:\n
 *              2003-01-21 Andrea Righi:
 *                      Suppressed deferencing type-punned pointer
 *                      warning.
 *      \note Copyright (&copy;) 2003 Andrea Righi
 */

#include <const.h>
#include <errno.h>

#include <kernel/console.h>

#include <net/ip.h>
#include <net/network.h>

#include <net/udp.h>

//! \brief
//!     Calculate the UDP checksum (calculated with the whole
//!     packet).
//! \param buff The UDP packet.
//! \param len The UDP packet length.
//! \param src_addr The IP source address (in network format).
//! \param dest_addr The IP destination address (in network format).
//! \return The result of the checksum.
uint16_t udp_checksum(const void *buff, size_t len, in_addr_t src_addr, in_addr_t dest_addr)
{
        const uint16_t *buf=buff;
        uint16_t *ip_src=(void *)&src_addr, *ip_dst=(void *)&dest_addr;
        uint32_t sum;
        size_t length=len;

        // Calculate the sum                                            //
        sum = 0;
        while (len > 1)
        {
                sum += *buf++;
                if (sum & 0x80000000)
                        sum = (sum & 0xFFFF) + (sum >> 16);
                len -= 2;
        }

        if ( len & 1 )
                // Add the padding if the packet lenght is odd          //
                sum += *((uint8_t *)buf);

        // Add the pseudo-header                                        //
        sum += *(ip_src++);
        sum += *ip_src;

        sum += *(ip_dst++);
        sum += *ip_dst;

        sum += htons(IPPROTO_UDP);
        sum += htons(length);

        // Add the carries                                              //
        while (sum >> 16)
                sum = (sum & 0xFFFF) + (sum >> 16);

        // Return the one's complement of sum                           //
        return ( (uint16_t)(~sum)  );
}

//! \brief
//!     Process an UDP packet received from the IP layer.
//! \param packet The UDP packet.
//! \param ip_src The IP source address (in network format).
//! \param ip_dst The IP destination address (in network format).
void to_udp_layer(udp_t *packet, in_addr_t ip_src, in_addr_t ip_dst)
{
        int i;
        bool chk;
        uint16_t len = ntohs(packet->udp_len) - sizeof(udp_t);

        // For UDP packets the checksum is optional; a value of 0 in    //
        // the checksum means the checksum is not used. A value of      //
        // 0xFFFF means the checksum is used and its value is 0.        //
        if ( packet->udp_chk != 0 )
        {
                // The checksum is used                                 //
                if ( packet->udp_chk == 0xFFFF )
                        packet->udp_chk = 0x0000;

                // Calculate the checksum                               //
                chk = udp_checksum(
                                packet,
                                ntohs(packet->udp_len),
                                ip_src,
                                ip_dst
                                );
                if ( chk )
                {
                        kprintf("\n\rUDP checksum error! %04X", chk);
                        return;
                }
        }

        // Dump the UDP packet                                          //
        kprintf(        "\n\rUDP packet received (%u bytes of data)"
                "\n\rsender  = %u.%u.%u.%u:%u"
                "\n\rreceiver= %u.%u.%u.%u:%u",
                len,

                IP_A(ntohl(ip_src)), IP_B(ntohl(ip_src)),
                IP_C(ntohl(ip_src)), IP_D(ntohl(ip_src)),
                ntohs(packet->udp_src),

                IP_A(ntohl(ip_dst)), IP_B(ntohl(ip_dst)),
                IP_C(ntohl(ip_dst)), IP_D(ntohl(ip_dst)),
                ntohs(packet->udp_dst)
        );

        kprintf("\n\rData:\n\r");
        for(i=0; i<len; i++)
                kputchar( (((uint8_t *)packet)+sizeof(udp_t))[i]  );
}

//! \brief Receive an UDP packet.
//! \param buf The buffer where the received packet will be copied.
//! \param len The maximum size of the buffer.
//! \param flags Flags.
//! \return The size of the packet received in bytes.
/**
 *      \todo
 *      Routine not implemented!
 *      For now return protocol not available error.
 */
int recv_udp_packet(udp_t *buf, size_t len, int flags)
{
        return( -ENOPROTOOPT );
}

---