---

eth.c

Go to the documentation of this file.

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

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

#include <arch/mem.h>
#include <arch/i386.h>

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

#include <net/arp.h>
#include <net/ip.h>
#include <net/network.h>
#include <net/rtl8139.h>
#include <net/tcp.h>

#include <net/eth.h>

extern rtl8139_t *rtl;

//! Ethernet receive buffer.
eth_buf_t *eth_recv_buf=NULL;

//! Daemon ethernet tasks 1.
task_t  *eth_recv_thread1=NULL,
//! Daemon ethernet tasks 2.
        *eth_recv_thread2=NULL;

// --- Initialization ------------------------------------------------- //

//! \brief Initialize the ethernet receive buffer.
void eth_init_buffer()
{
        // Create the receive buffer                                    //
        eth_recv_buf = kmalloc(sizeof(eth_buf_t));

        // Reset the receive buffer                                     //
        memset(eth_recv_buf, 0, sizeof(eth_buf_t));

        // Initialize buffer semaphores                                 //
        INIT_MUTEX(&eth_recv_buf->mutex);
}

// --- RECV routines -------------------------------------------------- //

//! \brief Receive data from the ethernet layer.
//! \param buf
//!     A buffer where the ethernet received packet will be copied.
//! \param len
//!     The max size of the buffer \p buf.
//! \param flags
//!     Flags.
//! \return The length in bytes of the packet received.
/**
 *      \todo \p flags parameter implementation.
 */
int recv_eth_packet(ethernet_t *buf, size_t len, int flags)
{
        dword IF = GET_IF();

        // If the recv buffer is empty, simply do nothing               //
        while(TRUE)
        {
                DOWN(&eth_recv_buf->mutex);

                if ( eth_recv_buf->count==0 )
                {
                        UP(&eth_recv_buf->mutex);
                        sleep_task( get_curr_task() );
                        enable();
                        idle();
                }
                else
                        // The buffer is not empty!                     //
                        break;
        }

        // Get the packet from the recv buffer and put it into the      //
        // requested pointer                                            //
        memcpy(
                buf,
                eth_recv_buf->packet[eth_recv_buf->read].data,
                len = MIN(len, eth_recv_buf->packet[eth_recv_buf->read].length)
        );
        // Update the read pointer and the recv buffer counter          //
        eth_recv_buf->read = (eth_recv_buf->read + 1) % ETH_RECV_BUF_DIM;
        (eth_recv_buf->count)--;

        UP(&eth_recv_buf->mutex);
        SET_IF(IF);

        // Return the length of the received packet                     //
        return( len );
}

//! \brief
//!     This daemon permanently reads packets from the recv buffer and
//!     send them to the opportune layer.
void eth_recv_daemon()
{
        unsigned i;
        size_t len;
        union
        {
                uint8_t raw[ETH_FRAME_LEN];
                ethernet_t eth;
        } packet;

        while(TRUE)
        {
                // Reset the buffer                                     //
                memset(packet.raw, 0, sizeof(packet.raw));
                // Listen the buffer                                    //
                len = recv_eth_packet(&packet.eth, sizeof(packet.raw), 0);

                // Send the packet to the right layer                   //
                switch( ntohs(packet.eth.type) )
                {
                        case ETH_FRAME_ARP:
                                to_arp_layer((arp_t *)(packet.eth.data));
                        break;

                        case ETH_FRAME_IP:
                                to_ip_layer((ip_t *)(packet.eth.data));
                        break;

                        default:
                                // Unknown magic number                 //
                                kprintf("\n\rPACK TYPE  = UNKNOWN (%04X)", htons(packet.eth.type));
                                // Dump the packet content              //
                                kprintf("\n\rDUMP:\n\r");
                                for (i=0; i<len; i++)
                                        kprintf("%02X ", packet.eth.data[i]);
                        break;
                }
        }
}

//! \brief
//!     Process an ethernet packet received from the physical layer.
//! \param packet The ethernet packet received.
//! \param len The size of the packet.
void to_eth_layer(ethernet_t *packet, size_t len)
{
        DOWN(&eth_recv_buf->mutex);

        #ifdef ETH_DEBUG
        // Strip the ethernet header                                    //
        kprintf("\n\rMAC DEST   = %02x:%02x:%02x:%02x:%02x:%02x",
                packet->dst[0], packet->dst[1], packet->dst[2],
                packet->dst[3], packet->dst[4], packet->dst[5]);
        kprintf("\n\rMAC SOURCE = %02x:%02x:%02x:%02x:%02x:%02x",
                packet->src[0], packet->src[1], packet->src[2],
                packet->src[3], packet->src[4], packet->src[5]);
        kprintf("\n\rPACK TYPE  = %04x", ntohs(packet->type));
        kprintf("\n\rTOT LENGTH = %u bytes", len);
        #endif

        // Store the packet data into the send buffer                   //
        memcpy(
                eth_recv_buf->packet[eth_recv_buf->write].data,
                packet,
                len = MIN(len, ETH_FRAME_LEN)
        );
        // Store the packet length                                      //
        eth_recv_buf->packet[eth_recv_buf->write].length = len;
        // Update the recv buffer write pointer                         //
        eth_recv_buf->write = (eth_recv_buf->write + 1) % ETH_RECV_BUF_DIM;

        if (eth_recv_buf->count <= ETH_RECV_BUF_DIM)
                // Update the packet counter                            //
                (eth_recv_buf->count)++;
        else
                // The oldest packet has been overwritten, so update    //
                // also the read pointer                                //
                eth_recv_buf->read = (eth_recv_buf->read + 1) % ETH_RECV_BUF_DIM;

        UP(&eth_recv_buf->mutex);

        // Wakeup the receive daemons                                   //
        wakeup_task( eth_recv_thread1 );
        wakeup_task( eth_recv_thread2 );
}

// --- SEND routines -------------------------------------------------- //

//! \brief Send an ethernet packet to the physiscal layer.
//! \param to The destination ethernet address (MAC).
//! \param data The buffer of data to be sent.
//! \param len The size of the buffer of data to be sent.
//! \param type The packet type.
//! \return
//!     \li The number of bytes sent in case of success.
//!     \li -#ENOMEM cannot allocate the packet structure.
//!     \li -#ENXIO no ethernet device found.
int send_eth_packet(const uint8_t *to, const void *data, size_t len, uint16_t type)
{
        uint8_t *packet;
        uint8_t *mac_addr;

        // Analyze the packet length (must be less than ETH_MTU)        //
        // TODO: if the packet length if great than ETH_MTU             //
        // perform a packet fragmentation.                              //
        len = MIN(len, ETH_MTU);

        // Create the ethernet packet                                   //
        packet = kmalloc( MAX(len+ETH_HEAD_LEN, ETH_MIN_LEN) );
        if (!packet)
                return(-ENOMEM);

        // Get the local mac address                                    //
        if ( (mac_addr = get_eth_mac_addr()) == NULL )
                // No such device or address!                           //
                return(-ENXIO);

        // Add the ethernet header to the packet                        //
        memcpy(packet, to, ETH_ADDR_LEN);
        memcpy(packet + ETH_ADDR_LEN, mac_addr, ETH_ADDR_LEN);
        memcpy(packet + 2 * ETH_ADDR_LEN, &type, sizeof(uint16_t));

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

        // Adjust the packet length including the size of the header    //
        len += ETH_HEAD_LEN;

        // Auto-pad! Send a minimum payload (another 4 bytes are        //
        // sent automatically for the FCS, totalling to 64 bytes)       //
        // It is the minimum length of an ethernet packet.              //
        while (len < ETH_MIN_LEN)
                packet[len++] = '\0';

        // Go to the physical layer                                     //
        len = send_rtl8139_packet(get_rtl8139_device(), packet, len);

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

        // Return the bytes transmitted at this level                   //
        return(len);
}

// --- Interface routines --------------------------------------------- //

//! \brief
//!     Check if the ethernet device has been configured in
//!     promiscuous mode.
//! \return
//!     \li #TRUE the ethernet card is in promiscuous mode;
//!     \li #FALSE the ethernet card is not in promiscuous mode.
bool is_eth_promisc()
{
        return( get_rtl8139_device()->promisc );
}

//! Default IP address for this host.
#define DEFAULT_IP_ADDR         ( IP_ADDRESS(10, 0, 0, 2) )
//! Default IP netmask for this host.
#define DEFAULT_NETMASK_ADDR    ( IP_ADDRESS(255, 0, 0, 0) )
//! \brief
//!     This is the "ifconfig" command for the shell.
//! \param cmd A string of command parameters.
void ifconfig(char *cmd)
{
        uint8_t ip_dot[STR_MAX_LENGTH];
        in_addr_t ip, netmask;

        // Skip initial spaces into the parameters string               //
        while (*cmd == ' ') cmd++;
        if (*cmd == '\0')
        {
                // Simply print current ethernet configuration          //
                rtl8139_dump_info(rtl);
                return;
        }
        if ( strstr(cmd, "up") )
        {
                if ( rtl != NULL )
                {
                        kprintf("\n\rRTL8139 is already up!");
                        if ( strstr(cmd, "promisc") )
                                rtl8139_promisc(get_rtl8139_device(), TRUE);
                        else
                                rtl8139_promisc(get_rtl8139_device(), FALSE);
                        kprintf("\n\rRTL8139: promiscuous mode %s\n\r",
                                (get_rtl8139_device()->promisc) ? "ENABLED" : "DISABLED");
                        return;
                }

                // Get the host IP and netmask                          //
                kprintf("\n\rIP address: ");
                gets(ip_dot);
                if ( !inet_aton(ip_dot, &ip) )
                {
                        // Set the IP to default value                  //
                        ip = DEFAULT_IP_ADDR;
                }
                kprintf("\rNetmask   : ");
                gets(ip_dot);
                if ( !inet_aton(ip_dot, &netmask) )
                {
                        // Set the netmask to default value             //
                        netmask = DEFAULT_NETMASK_ADDR;
                }

                // Set the host ip and netmask addresses                //
                set_host_ip_net(ip, netmask);
                // Initialize the ethernet buffer                       //
                eth_init_buffer();
                // Reset the ARP cache                                  //
                arp_reset_cache();

                // Open the TCP module                                  //
                tcp_module_init();

                // Initialize the RTL8139 device                        //
                switch( rtl8139_init(strstr(cmd, "promisc") ? TRUE : FALSE) )
                {
                        case ( 0 ):
                        // --- SUCCESS ---                              //
                        // Dump the ethernet card informations          //
                        rtl8139_dump_info(rtl);
                        // Create the ethernet receiver thread          //
                        eth_recv_thread1 =
                                create_process(
                                        &eth_recv_daemon, &eth_recv_daemon,
                                        0, "eth_recvd1", KERNEL_PRIVILEGE);
                        eth_recv_thread2 =
                                create_process(
                                        &eth_recv_daemon, &eth_recv_daemon,
                                        0, "eth_recvd2", KERNEL_PRIVILEGE);
                        break;

                        case ( -ENXIO ):
                        // --- DEVICE NOT FOUND ---                     //
                        // Null the host ip and netmask                 //
                        set_host_ip_net(0, 0);
                        // Destroy the ethernet buffer                  //
                        kfree( eth_recv_buf );
                        // Print the error message                      //
                        kprintf("\n\rRTL8139: cannot find an ethernet card!\n\r");
                        break;

                        case ( -EIO ):
                        // --- I/O ERROR ---                            //
                        // Null the host ip and netmask                 //
                        set_host_ip_net(0, 0);
                        // Destroy the ethernet buffer                  //
                        kfree( eth_recv_buf );
                        // Print the error message                      //
                        kprintf("\n\rRTL8139: I/O error!\n\r");
                        break;
                }
                return;
        }
        if ( strstr(cmd, "down") )
        {
                kprintf("\n\rRTL8139: shutting down eth0 device...");

                // Close the TCP module                                 //
                tcp_module_close();

                // Destroy the ethernet buffer                          //
                kfree( eth_recv_buf );
                // Kill the ethernet receiver thread                    //
                kill(eth_recv_thread1->pid);
                kill(eth_recv_thread2->pid);
                // Reset the ARP cache                                  //
                arp_reset_cache();
                // Close the RTL8139 interface                          //
                rtl8139_close(&rtl);
                kprintf("\n\r");
                return;
        }

        // Command unknown!                                             //
        kprintf("\n\rerror: %s unknown!\n\r", cmd);
}

---