---

ip.c

Go to the documentation of this file.

/*!     \file network/ip.c
 *      \brief IP (Internet Protocol) layer.
 *      \author Andrea Righi <drizzt@inwind.it>
 *      \date Last update: 2003-11-09
 *      \note Copyright (&copy;) 2003 Andrea Righi
 */

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

#include <arch/mem.h>

#include <kernel/clock.h>
#include <kernel/console.h>
#include <kernel/kmalloc.h>

#include <net/arp.h>
#include <net/eth.h>
#include <net/icmp.h>
#include <net/network.h>
#include <net/tcp.h>
#include <net/udp.h>

#include <net/ip.h>

//! \brief Calculate the IP header checksum.
//! \param buf The IP header content.
//! \param hdr_len The IP header length.
//! \return The result of the checksum.
uint16_t ip_checksum(const void *buf, size_t hdr_len)
{
        unsigned long sum = 0;
        const uint16_t *ip1;

        ip1 = buf;
        while (hdr_len > 1)
        {
                sum += *ip1++;
                if (sum & 0x80000000)
                        sum = (sum & 0xFFFF) + (sum >> 16);
                hdr_len -= 2;
        }

        while (sum >> 16)
                sum = (sum & 0xFFFF) + (sum >> 16);

        return(~sum);
}

//! \brief Dump an IP packet to the standard output.
//! \param packet The IP packet.
void dump_ip_packet(ip_t *packet)
{
        int i;
        uint8_t *data = ((void *)packet + (packet->ip_hdr_len * sizeof(uint32_t)));

        // Dump the IP header                                           //
        kprintf(        "\n\r(ip header)"
                "\n\rhdr_len:%u dwords, ip_version:%u, ToS:%#04X, tot_len:%u"
                "\n\rid:%#010x, off:%#010x, TTL:%u, proto:%#04X, ip_chk:%#06X"
                "\n\rip_src:%u.%u.%u.%u, ip_dst:%u.%u.%u.%u",
                packet->ip_hdr_len, packet->ip_version, packet->ip_tos,
                ntohs(packet->ip_len), ntohs(packet->ip_id), ntohs(packet->ip_off),
                packet->ip_ttl, packet->ip_proto,
                ntohs(packet->ip_chk),

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

                IP_A(ntohl(packet->ip_dst)), IP_B(ntohl(packet->ip_dst)),
                IP_C(ntohl(packet->ip_dst)), IP_D(ntohl(packet->ip_dst))
        );
        // Dump the IP data section                                     //
        kprintf("\n\r(ip data)\n\r");
        for (i=0; i<(ntohs(packet->ip_len) - packet->ip_hdr_len * sizeof(uint32_t)); i++)
                if ( isprint(data[i]) )
                        kputchar(data[i]);
                else
                        kputchar('.');
}

//! This is the IP address of this host (expressed in network format).
static in_addr_t host_ip;
//! This is the IP netmask of this host (expressed in network format).
static in_addr_t host_netmask;

//! \brief Set the IP and netmask for this host.
//! \param ip The IP address in network format.
//! \param netmask The netmask in network format.
void set_host_ip_net(in_addr_t ip, in_addr_t netmask)
{
        host_ip = ip;
        host_netmask = netmask;
}

//! \brief Get the IP address of this host.
//! \return
//!     The IP address expressed in network format.
in_addr_t get_host_ip()
{
        return( host_ip );
}

//! \brief Get the netmask of this host.
//! \return
//!     The netmask expressed in network format.
in_addr_t get_host_netmask()
{
        return( host_netmask );
}

//! \brief Get the broadcast address of the local network.
//! \return
//!     The broadcast address of this local network expressed
//!     in network format.
in_addr_t get_host_bcast()
{
        return( (~host_netmask) | (host_ip & host_netmask) );
}

//! \brief
//!     Converts an internet IP addres from number-and-dot string
//!     notation into binary data network byte order.
//! \param cp
//!     The string of the number-and-dot notation IP address.
//! \param inp
//!     The destination where the binary network byte order address
//!     will be put.
//! \return Nonzero if the address is valid, zero if not.
int inet_aton(const char *cp, in_addr_t *inp)
{
        static const in_addr_t max[4] = { 0xFFFFFFFF, 0xFFFFFF, 0xFFFF, 0xFF };
        in_addr_t val;
        char c;
        union iaddr {
          uint8_t bytes[4];
          uint32_t word;
        } res;
        uint8_t *pp = res.bytes;
        int digit,base;

        res.word = 0;

        c = *cp;
        for (;;) {
                // Collect number up to '.'                             //
                // Values are specified as for C:                       //
                // 0x=hex, 0=octal, isdigit=decimal.                    //
                if (!isdigit(c)) goto ret_0;
                val = 0; base = 10; digit = 0;
                for (;;) {
                        if (isdigit(c)) {
                                val = (val * base) + (c - '0');
                                c = *++cp;
                                digit = 1;
                        } else {
                                break;
                        }
                }
                if (c == '.') {
                        // Internet format:                             //
                        //      a.b.c.d                                 //
                        //      a.b.c   (with c treated as 16 bits)     //
                        //      a.b     (with b treated as 24 bits)     //
                        if (pp > res.bytes + 2 || val > 0xff) {
                                goto ret_0;
                        }
                        *pp++ = val;
                        c = *++cp;
                } else
                        break;
        }

        // Check for trailing characters                                //
        if (c != '\0' && (!isascii(c) || !isspace(c))) {
                goto ret_0;
        }

        // Did we get a valid digit?                                    //
        if (!digit) {
                goto ret_0;
        }

        // Check whether the last part is in its limits depending on    //
        // the number of parts in total.                                //
        if (val > max[pp - res.bytes]) {
                goto ret_0;
        }

        if (inp != NULL) {
                *inp = res.word | htonl (val);
        }

        return (1);
ret_0:
        return (0);
}

//! \brief Process an IP packet received from the ethernet layer.
//! \param packet The IP packet.
void to_ip_layer(ip_t *packet)
{
        // Calculate the header checksum                                //
        if ( ip_checksum(packet, packet->ip_hdr_len * sizeof(dword)) )
        {
                kprintf("\n\rip header checksum error!!!");
                return;
        }

        //--------------------------------------------------------------//
        // Check if we can receive the packet or not                    //
        if (
                (packet->ip_dst!=get_host_ip()) &&
                (packet->ip_dst!=get_host_bcast()) &&
                (packet->ip_dst!=INADDR_BROADCAST)
        )
                return;
        //--------------------------------------------------------------//

        // Identify the right protocol                                  //
        switch( packet->ip_proto )
        {
                case IPPROTO_ICMP:
                        // ICMP (Internet Control Message Protocol)     //
                        to_icmp_layer(packet);
                break;

                case IPPROTO_IGMP:
                        // Internet Group Message Protocol)             //
                        kprintf("\n\rIGMP protocol not yet implemented!");
                        dump_ip_packet(packet);
                break;

                case IPPROTO_TCP:
                        // TCP (Transmition Control Protocol)           //
                        to_tcp_layer(
                                ((void *)packet + (packet->ip_hdr_len * sizeof(uint32_t))),
                                (ntohs(packet->ip_len) - (packet->ip_hdr_len * sizeof(uint32_t))),
                                packet->ip_src,
                                packet->ip_dst
                        );
                        // dump_ip_packet(packet);
                break;

                case IPPROTO_UDP:
                        // UDP (User Datagram Protocol)                 //
                        to_udp_layer(
                                ((void *)packet + (packet->ip_hdr_len * sizeof(uint32_t))),
                                packet->ip_src,
                                packet->ip_dst
                        );
                break;

                default:
                        kprintf("\n\rUnknown IP protocol!");
                        dump_ip_packet(packet);
                break;
        }
}

//! \brief Send an IP packet to the ethernet layer.
//! \param ip_to The IP destination address in network format.
//! \param data The buffer of data to be sent.
//! \param len The size of the buffer to be sent.
//! \param ttl TTL (Time To Live).
//! \param proto The upper-layer protocol type.
//! \return
//!     \li The number of bytes sent in case of success;
//!     \li -#EMSGSIZE the packet is too big to be sent;
//!     \li -#ENOMEM cannot allocate the packet structure;
//!     \li -#ENETUNREACH destination address not found;
int send_ip_packet(uint32_t ip_to, const void *data, size_t len, uint8_t ttl, uint8_t proto)
{
        uint8_t eth_to[ETH_ADDR_LEN];
        size_t packet_len = len + sizeof(ip_t);
        ip_t *packet;
        int tot_len;

        if (packet_len > IP_FRAME_LEN)
                return(-EMSGSIZE);

        packet = kmalloc(packet_len);
        if (packet == NULL)
                return(-ENOMEM);

        // Create the IP header                                         //
        packet->ip_version = IP_V4;
        packet->ip_hdr_len = sizeof(ip_t) / sizeof(dword);
        packet->ip_tos = 0;
        packet->ip_len = htons(packet_len);
        packet->ip_id = htons(0xDEAD);  // :-) //
        packet->ip_off = htons(IP_FLAG_DF | 0);
        packet->ip_ttl = ttl;
        packet->ip_proto = proto;
        packet->ip_chk = 0;
        packet->ip_dst = ip_to;
        packet->ip_src = get_host_ip();
        packet->ip_chk = ip_checksum(packet, sizeof(ip_t));

        // Copy the data into the packet                                //
        memcpy(packet + 1, data, len);

        // Translate the IP address into ethernet address               //
        // using the ARP protocol.                                      //
        if ( !arp_ip_to_eth(eth_to, ip_to) )
        {
                #ifdef DEBUG
                kprintf("\n\rARP fails!");
                #endif
                // The ethernet address was not found!                  //
                return(-ENETUNREACH);
        }
        #ifdef DEBUG
        kprintf("\n\rsending eth packet to %02x:%02x:%02x:%02x:%02x:%02x...",
                eth_to[0], eth_to[1], eth_to[2], eth_to[3], eth_to[4], eth_to[5]
        );
        #endif

        // Go to the ethernet layer...                                  //
        tot_len = send_eth_packet(eth_to, packet, packet_len, htons(ETH_FRAME_IP));

        #ifdef DEBUG
        kprintf("\n\r%u bytes sent from ethernet layer", tot_len);
        #endif

        // Free the memory of the packet                                //
        kfree(packet);

        if ( tot_len < 0 )
                // Something wrong from at the ethernet layer           //
                return(tot_len);

        // Well done!                                                   //
        return(packet_len);
}

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

---