arp.c

Go to the documentation of this file.

/*
 * Copyright (c) 2009 Lukas Mejdrech
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * - Redistributions of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 * - Redistributions in binary form must reproduce the above copyright
 *   notice, this list of conditions and the following disclaimer in the
 *   documentation and/or other materials provided with the distribution.
 * - The name of the author may not be used to endorse or promote products
 *   derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#include <async.h>
#include <malloc.h>
#include <mem.h>
#include <fibril_synch.h>
#include <assert.h>
#include <stdio.h>
#include <str.h>
#include <task.h>
#include <adt/measured_strings.h>
#include <ipc/services.h>
#include <ipc/net.h>
#include <ipc/arp.h>
#include <ipc/il.h>
#include <ipc/nil.h>
#include <byteorder.h>
#include <errno.h>
#include <net/modules.h>
#include <net/device.h>
#include <net/packet.h>
#include <nil_remote.h>
#include <protocol_map.h>
#include <packet_client.h>
#include <packet_remote.h>
#include <il_remote.h>
#include <il_skel.h>
#include "arp.h"

#define NAME  "arp"

#define ARP_TRANS_WAIT  1000000


#define ARPOP_REQUEST  1

#define ARPOP_REPLY  2

typedef struct arp_header arp_header_t;

struct arp_header {
        uint16_t hardware;
        
        uint16_t protocol;
        uint8_t hardware_length;
        uint8_t protocol_length;
        
        uint16_t operation;
} __attribute__ ((packed));

arp_globals_t arp_globals;

DEVICE_MAP_IMPLEMENT(arp_cache, arp_device_t);
INT_MAP_IMPLEMENT(arp_protos, arp_proto_t);
GENERIC_CHAR_MAP_IMPLEMENT(arp_addr, arp_trans_t);

static void arp_clear_trans(arp_trans_t *trans)
{
        if (trans->hw_addr) {
                free(trans->hw_addr);
                trans->hw_addr = NULL;
        }
        
        fibril_condvar_broadcast(&trans->cv);
}

static void arp_clear_addr(arp_addr_t *addresses)
{
        int count;
        
        for (count = arp_addr_count(addresses) - 1; count >= 0; count--) {
                arp_trans_t *trans = arp_addr_items_get_index(&addresses->values,
                    count);
                if (trans)
                        arp_clear_trans(trans);
        }
}

static void arp_clear_device(arp_device_t *device)
{
        int count;
        
        for (count = arp_protos_count(&device->protos) - 1; count >= 0;
            count--) {
                arp_proto_t *proto = arp_protos_get_index(&device->protos,
                    count);
                
                if (proto) {
                        if (proto->addr)
                                free(proto->addr);
                        
                        if (proto->addr_data)
                                free(proto->addr_data);
                        
                        arp_clear_addr(&proto->addresses);
                        arp_addr_destroy(&proto->addresses, free);
                }
        }
        
        arp_protos_clear(&device->protos, free);
}

static int arp_clean_cache_req(int arp_phone)
{
        int count;
        
        fibril_mutex_lock(&arp_globals.lock);
        for (count = arp_cache_count(&arp_globals.cache) - 1; count >= 0;
            count--) {
                arp_device_t *device = arp_cache_get_index(&arp_globals.cache,
                    count);
                
                if (device) {
                        arp_clear_device(device);
                        if (device->addr_data)
                                free(device->addr_data);
                        
                        if (device->broadcast_data)
                                free(device->broadcast_data);
                }
        }
        
        arp_cache_clear(&arp_globals.cache, free);
        fibril_mutex_unlock(&arp_globals.lock);
        
        return EOK;
}

static int arp_clear_address_req(int arp_phone, device_id_t device_id,
    services_t protocol, measured_string_t *address)
{
        fibril_mutex_lock(&arp_globals.lock);
        
        arp_device_t *device = arp_cache_find(&arp_globals.cache, device_id);
        if (!device) {
                fibril_mutex_unlock(&arp_globals.lock);
                return ENOENT;
        }
        
        arp_proto_t *proto = arp_protos_find(&device->protos, protocol);
        if (!proto) {
                fibril_mutex_unlock(&arp_globals.lock);
                return ENOENT;
        }
        
        arp_trans_t *trans = arp_addr_find(&proto->addresses, address->value,
            address->length);
        if (trans)
                arp_clear_trans(trans);
        
        arp_addr_exclude(&proto->addresses, address->value, address->length, free);
        
        fibril_mutex_unlock(&arp_globals.lock);
        return EOK;
}

static int arp_clear_device_req(int arp_phone, device_id_t device_id)
{
        fibril_mutex_lock(&arp_globals.lock);
        
        arp_device_t *device = arp_cache_find(&arp_globals.cache, device_id);
        if (!device) {
                fibril_mutex_unlock(&arp_globals.lock);
                return ENOENT;
        }
        
        arp_clear_device(device);
        
        fibril_mutex_unlock(&arp_globals.lock);
        return EOK;
}

static int arp_proto_create(arp_proto_t **proto, services_t service,
    measured_string_t *address)
{
        *proto = (arp_proto_t *) malloc(sizeof(arp_proto_t));
        if (!*proto)
                return ENOMEM;
        
        (*proto)->service = service;
        (*proto)->addr = address;
        (*proto)->addr_data = address->value;
        
        int rc = arp_addr_initialize(&(*proto)->addresses);
        if (rc != EOK) {
                free(*proto);
                return rc;
        }
        
        return EOK;
}

static int arp_receive_message(device_id_t device_id, packet_t *packet)
{
        int rc;
        
        size_t length = packet_get_data_length(packet);
        if (length <= sizeof(arp_header_t))
                return EINVAL;
        
        arp_device_t *device = arp_cache_find(&arp_globals.cache, device_id);
        if (!device)
                return ENOENT;
        
        arp_header_t *header = (arp_header_t *) packet_get_data(packet);
        if ((ntohs(header->hardware) != device->hardware) ||
            (length < sizeof(arp_header_t) + header->hardware_length * 2U +
            header->protocol_length * 2U)) {
                return EINVAL;
        }
        
        arp_proto_t *proto = arp_protos_find(&device->protos,
            protocol_unmap(device->service, ntohs(header->protocol)));
        if (!proto)
                return ENOENT;
        
        uint8_t *src_hw = ((uint8_t *) header) + sizeof(arp_header_t);
        uint8_t *src_proto = src_hw + header->hardware_length;
        uint8_t *des_hw = src_proto + header->protocol_length;
        uint8_t *des_proto = des_hw + header->hardware_length;
        
        arp_trans_t *trans = arp_addr_find(&proto->addresses, src_proto,
            header->protocol_length);
        
        if ((trans) && (trans->hw_addr)) {
                /* Translation exists */
                if (trans->hw_addr->length != header->hardware_length)
                        return EINVAL;
                
                memcpy(trans->hw_addr->value, src_hw, trans->hw_addr->length);
        }
        
        /* Is my protocol address? */
        if (proto->addr->length != header->protocol_length)
                return EINVAL;
        
        if (!bcmp(proto->addr->value, des_proto, proto->addr->length)) {
                if (!trans) {
                        /* Update the translation */
                        trans = (arp_trans_t *) malloc(sizeof(arp_trans_t));
                        if (!trans)
                                return ENOMEM;
                        
                        trans->hw_addr = NULL;
                        fibril_condvar_initialize(&trans->cv);
                        rc = arp_addr_add(&proto->addresses, src_proto,
                            header->protocol_length, trans);
                        if (rc != EOK) {
                                free(trans);
                                return rc;
                        }
                }
                
                if (!trans->hw_addr) {
                        trans->hw_addr = measured_string_create_bulk(src_hw,
                            header->hardware_length);
                        if (!trans->hw_addr)
                                return ENOMEM;
                        
                        /* Notify the fibrils that wait for the translation. */
                        fibril_condvar_broadcast(&trans->cv);
                }
                
                if (ntohs(header->operation) == ARPOP_REQUEST) {
                        header->operation = htons(ARPOP_REPLY);
                        memcpy(des_proto, src_proto, header->protocol_length);
                        memcpy(src_proto, proto->addr->value,
                            header->protocol_length);
                        memcpy(src_hw, device->addr->value,
                            device->packet_dimension.addr_len);
                        memcpy(des_hw, trans->hw_addr->value,
                            header->hardware_length);
                        
                        rc = packet_set_addr(packet, src_hw, des_hw,
                            header->hardware_length);
                        if (rc != EOK)
                                return rc;
                        
                        nil_send_msg(device->phone, device_id, packet,
                            SERVICE_ARP);
                        return 1;
                }
        }
        
        return EOK;
}

static int arp_mtu_changed_message(device_id_t device_id, size_t mtu)
{
        fibril_mutex_lock(&arp_globals.lock);
        
        arp_device_t *device = arp_cache_find(&arp_globals.cache, device_id);
        if (!device) {
                fibril_mutex_unlock(&arp_globals.lock);
                return ENOENT;
        }
        
        device->packet_dimension.content = mtu;
        
        fibril_mutex_unlock(&arp_globals.lock);
        
        printf("%s: Device %d changed MTU to %zu\n", NAME, device_id, mtu);
        
        return EOK;
}

static void arp_receiver(ipc_callid_t iid, ipc_call_t *icall)
{
        packet_t *packet;
        int rc;
        
        while (true) {
                switch (IPC_GET_IMETHOD(*icall)) {
                case NET_IL_DEVICE_STATE:
                        /* Do nothing - keep the cache */
                        async_answer_0(iid, (sysarg_t) EOK);
                        break;
                
                case NET_IL_RECEIVED:
                        rc = packet_translate_remote(arp_globals.net_phone, &packet,
                            IPC_GET_PACKET(*icall));
                        if (rc == EOK) {
                                fibril_mutex_lock(&arp_globals.lock);
                                do {
                                        packet_t *next = pq_detach(packet);
                                        rc = arp_receive_message(IPC_GET_DEVICE(*icall), packet);
                                        if (rc != 1) {
                                                pq_release_remote(arp_globals.net_phone,
                                                    packet_get_id(packet));
                                        }
                                        
                                        packet = next;
                                } while (packet);
                                fibril_mutex_unlock(&arp_globals.lock);
                        }
                        async_answer_0(iid, (sysarg_t) rc);
                        break;
                
                case NET_IL_MTU_CHANGED:
                        rc = arp_mtu_changed_message(IPC_GET_DEVICE(*icall),
                            IPC_GET_MTU(*icall));
                        async_answer_0(iid, (sysarg_t) rc);
                        break;
                
                default:
                        async_answer_0(iid, (sysarg_t) ENOTSUP);
                }
                
                iid = async_get_call(icall);
        }
}

static int arp_device_message(device_id_t device_id, services_t service,
    services_t protocol, measured_string_t *address)
{
        int index;
        int rc;
        
        fibril_mutex_lock(&arp_globals.lock);
        
        /* An existing device? */
        arp_device_t *device = arp_cache_find(&arp_globals.cache, device_id);
        if (device) {
                if (device->service != service) {
                        printf("%s: Device %d already exists\n", NAME,
                            device->device_id);
                        fibril_mutex_unlock(&arp_globals.lock);
                        return EEXIST;
                }
                
                arp_proto_t *proto = arp_protos_find(&device->protos, protocol);
                if (proto) {
                        free(proto->addr);
                        free(proto->addr_data);
                        proto->addr = address;
                        proto->addr_data = address->value;
                } else {
                        rc = arp_proto_create(&proto, protocol, address);
                        if (rc != EOK) {
                                fibril_mutex_unlock(&arp_globals.lock);
                                return rc;
                        }
                        
                        index = arp_protos_add(&device->protos, proto->service,
                            proto);
                        if (index < 0) {
                                fibril_mutex_unlock(&arp_globals.lock);
                                free(proto);
                                return index;
                        }
                        
                        printf("%s: New protocol added (id: %d, proto: %d)\n", NAME,
                            device_id, protocol);
                }
        } else {
                hw_type_t hardware = hardware_map(service);
                if (!hardware)
                        return ENOENT;
                
                /* Create new device */
                device = (arp_device_t *) malloc(sizeof(arp_device_t));
                if (!device) {
                        fibril_mutex_unlock(&arp_globals.lock);
                        return ENOMEM;
                }
                
                device->hardware = hardware;
                device->device_id = device_id;
                rc = arp_protos_initialize(&device->protos);
                if (rc != EOK) {
                        fibril_mutex_unlock(&arp_globals.lock);
                        free(device);
                        return rc;
                }
                
                arp_proto_t *proto;
                rc = arp_proto_create(&proto, protocol, address);
                if (rc != EOK) {
                        fibril_mutex_unlock(&arp_globals.lock);
                        free(device);
                        return rc;
                }
                
                index = arp_protos_add(&device->protos, proto->service, proto);
                if (index < 0) {
                        fibril_mutex_unlock(&arp_globals.lock);
                        arp_protos_destroy(&device->protos, free);
                        free(device);
                        return index;
                }
                
                device->service = service;
                
                /* Bind */
                device->phone = nil_bind_service(device->service,
                    (sysarg_t) device->device_id, SERVICE_ARP,
                    arp_receiver);
                if (device->phone < 0) {
                        fibril_mutex_unlock(&arp_globals.lock);
                        arp_protos_destroy(&device->protos, free);
                        free(device);
                        return EREFUSED;
                }
                
                /* Get packet dimensions */
                rc = nil_packet_size_req(device->phone, device_id,
                    &device->packet_dimension);
                if (rc != EOK) {
                        fibril_mutex_unlock(&arp_globals.lock);
                        arp_protos_destroy(&device->protos, free);
                        free(device);
                        return rc;
                }
                
                /* Get hardware address */
                rc = nil_get_addr_req(device->phone, device_id, &device->addr,
                    &device->addr_data);
                if (rc != EOK) {
                        fibril_mutex_unlock(&arp_globals.lock);
                        arp_protos_destroy(&device->protos, free);
                        free(device);
                        return rc;
                }
                
                /* Get broadcast address */
                rc = nil_get_broadcast_addr_req(device->phone, device_id,
                    &device->broadcast_addr, &device->broadcast_data);
                if (rc != EOK) {
                        fibril_mutex_unlock(&arp_globals.lock);
                        free(device->addr);
                        free(device->addr_data);
                        arp_protos_destroy(&device->protos, free);
                        free(device);
                        return rc;
                }
                
                rc = arp_cache_add(&arp_globals.cache, device->device_id,
                    device);
                if (rc != EOK) {
                        fibril_mutex_unlock(&arp_globals.lock);
                        free(device->addr);
                        free(device->addr_data);
                        free(device->broadcast_addr);
                        free(device->broadcast_data);
                        arp_protos_destroy(&device->protos, free);
                        free(device);
                        return rc;
                }
                printf("%s: Device registered (id: %d, type: 0x%x, service: %d,"
                    " proto: %d)\n", NAME, device->device_id, device->hardware,
                    device->service, protocol);
        }
        
        fibril_mutex_unlock(&arp_globals.lock);
        return EOK;
}

int il_initialize(int net_phone)
{
        fibril_mutex_initialize(&arp_globals.lock);
        
        fibril_mutex_lock(&arp_globals.lock);
        arp_globals.net_phone = net_phone;
        int rc = arp_cache_initialize(&arp_globals.cache);
        fibril_mutex_unlock(&arp_globals.lock);
        
        return rc;
}

static int arp_send_request(device_id_t device_id, services_t protocol,
    measured_string_t *target, arp_device_t *device, arp_proto_t *proto)
{
        /* ARP packet content size = header + (address + translation) * 2 */
        size_t length = 8 + 2 * (proto->addr->length + device->addr->length);
        if (length > device->packet_dimension.content)
                return ELIMIT;
        
        packet_t *packet = packet_get_4_remote(arp_globals.net_phone,
            device->packet_dimension.addr_len, device->packet_dimension.prefix,
            length, device->packet_dimension.suffix);
        if (!packet)
                return ENOMEM;
        
        arp_header_t *header = (arp_header_t *) packet_suffix(packet, length);
        if (!header) {
                pq_release_remote(arp_globals.net_phone, packet_get_id(packet));
                return ENOMEM;
        }
        
        header->hardware = htons(device->hardware);
        header->hardware_length = (uint8_t) device->addr->length;
        header->protocol = htons(protocol_map(device->service, protocol));
        header->protocol_length = (uint8_t) proto->addr->length;
        header->operation = htons(ARPOP_REQUEST);
        
        length = sizeof(arp_header_t);
        
        memcpy(((uint8_t *) header) + length, device->addr->value,
            device->addr->length);
        length += device->addr->length;
        memcpy(((uint8_t *) header) + length, proto->addr->value,
            proto->addr->length);
        length += proto->addr->length;
        bzero(((uint8_t *) header) + length, device->addr->length);
        length += device->addr->length;
        memcpy(((uint8_t *) header) + length, target->value, target->length);
        
        int rc = packet_set_addr(packet, (uint8_t *) device->addr->value,
            (uint8_t *) device->broadcast_addr->value, device->addr->length);
        if (rc != EOK) {
                pq_release_remote(arp_globals.net_phone, packet_get_id(packet));
                return rc;
        }
        
        nil_send_msg(device->phone, device_id, packet, SERVICE_ARP);
        return EOK;
}

static int arp_translate_message(device_id_t device_id, services_t protocol,
    measured_string_t *target, measured_string_t **translation)
{
        bool retry = false;
        int rc;

        assert(fibril_mutex_is_locked(&arp_globals.lock));
        
restart:
        if ((!target) || (!translation))
                return EBADMEM;
        
        arp_device_t *device = arp_cache_find(&arp_globals.cache, device_id);
        if (!device)
                return ENOENT;
        
        arp_proto_t *proto = arp_protos_find(&device->protos, protocol);
        if ((!proto) || (proto->addr->length != target->length))
                return ENOENT;
        
        arp_trans_t *trans = arp_addr_find(&proto->addresses, target->value,
            target->length);
        if (trans) {
                if (trans->hw_addr) {
                        /* The translation is in place. */
                        *translation = trans->hw_addr;
                        return EOK;
                }
                
                if (retry) {
                        /*
                         * We may get here as a result of being signalled for
                         * some reason while waiting for the translation (e.g.
                         * translation becoming available, record being removed
                         * from the table) and then losing the race for
                         * the arp_globals.lock with someone else who modified
                         * the table.
                         *
                         * Remove the incomplete record so that it is possible
                         * to make new ARP requests.
                         */
                        arp_clear_trans(trans);
                        arp_addr_exclude(&proto->addresses, target->value,
                            target->length, free);
                        return EAGAIN;
                }
                
                /*
                 * We are a random passer-by who merely joins an already waiting
                 * fibril in waiting for the translation.
                 */
                rc = fibril_condvar_wait_timeout(&trans->cv, &arp_globals.lock,
                    ARP_TRANS_WAIT);
                if (rc == ETIMEOUT)
                        return ENOENT;
                
                /*
                 * Need to recheck because we did not hold the lock while
                 * sleeping on the condition variable.
                 */
                retry = true;
                goto restart;
        }
        
        if (retry)
                return EAGAIN;

        /*
         * We are under the protection of arp_globals.lock, so we can afford to
         * first send the ARP request and then insert an incomplete ARP record.
         * The incomplete record is used to tell any other potential waiter
         * that this fibril has already sent the request and that it is waiting
         * for the answer. Lastly, any fibril which sees the incomplete request
         * can perform a timed wait on its condition variable to wait for the
         * ARP reply to arrive.
         */

        rc = arp_send_request(device_id, protocol, target, device, proto);
        if (rc != EOK)
                return rc;
        
        trans = (arp_trans_t *) malloc(sizeof(arp_trans_t));
        if (!trans)
                return ENOMEM;
        
        trans->hw_addr = NULL;
        fibril_condvar_initialize(&trans->cv);
        
        rc = arp_addr_add(&proto->addresses, target->value, target->length,
            trans);
        if (rc != EOK) {
                free(trans);
                return rc;
        }
        
        rc = fibril_condvar_wait_timeout(&trans->cv, &arp_globals.lock,
            ARP_TRANS_WAIT);
        if (rc == ETIMEOUT) {
                /*
                 * Remove the incomplete record so that it is possible to make 
                 * new ARP requests.
                 */
                arp_clear_trans(trans);
                arp_addr_exclude(&proto->addresses, target->value,
                    target->length, free);
                return ENOENT;
        }
        
        /*
         * We need to recheck that the translation has indeed become available,
         * because we dropped the arp_globals.lock while sleeping on the
         * condition variable and someone else might have e.g. removed the
         * translation before we managed to lock arp_globals.lock again.
         */

        retry = true;
        goto restart;
}

int il_module_message(ipc_callid_t callid, ipc_call_t *call, ipc_call_t *answer,
    size_t *count)
{
        measured_string_t *address;
        measured_string_t *translation;
        uint8_t *data;
        int rc;
        
        *count = 0;
        switch (IPC_GET_IMETHOD(*call)) {
        case IPC_M_PHONE_HUNGUP:
                return EOK;
        
        case NET_ARP_DEVICE:
                rc = measured_strings_receive(&address, &data, 1);
                if (rc != EOK)
                        return rc;
                
                rc = arp_device_message(IPC_GET_DEVICE(*call),
                    IPC_GET_SERVICE(*call), ARP_GET_NETIF(*call), address);
                if (rc != EOK) {
                        free(address);
                        free(data);
                }
                
                return rc;
        
        case NET_ARP_TRANSLATE:
                rc = measured_strings_receive(&address, &data, 1);
                if (rc != EOK)
                        return rc;
                
                fibril_mutex_lock(&arp_globals.lock);
                rc = arp_translate_message(IPC_GET_DEVICE(*call),
                    IPC_GET_SERVICE(*call), address, &translation);
                free(address);
                free(data);
                
                if (rc != EOK) {
                        fibril_mutex_unlock(&arp_globals.lock);
                        return rc;
                }
                
                if (!translation) {
                        fibril_mutex_unlock(&arp_globals.lock);
                        return ENOENT;
                }
                
                rc = measured_strings_reply(translation, 1);
                fibril_mutex_unlock(&arp_globals.lock);
                return rc;
        
        case NET_ARP_CLEAR_DEVICE:
                return arp_clear_device_req(0, IPC_GET_DEVICE(*call));
        
        case NET_ARP_CLEAR_ADDRESS:
                rc = measured_strings_receive(&address, &data, 1);
                if (rc != EOK)
                        return rc;
                
                arp_clear_address_req(0, IPC_GET_DEVICE(*call),
                    IPC_GET_SERVICE(*call), address);
                free(address);
                free(data);
                return EOK;
        
        case NET_ARP_CLEAN_CACHE:
                return arp_clean_cache_req(0);
        }
        
        return ENOTSUP;
}

int main(int argc, char *argv[])
{
        /* Start the module */
        return il_module_start(SERVICE_ARP);
}

---