WebSVN – HelenOS – Diff – /branches/network/uspace/srv/net/il/ip/ip.c


/*
 * 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.
 */
 
/** @addtogroup ip
 *  @{
 */
 
/** @file
 *  IP module implementation.
 *  @see arp.h
 
 */
 
#include <async.h>
#include <errno.h>
#include <fibril_sync.h>
#include <stdio.h>
#include <string.h>
 
#include <ipc/ipc.h>
#include <ipc/services.h>
 
#include <sys/types.h>
 
#include "../../err.h"
#include "../../messages.h"
#include "../../modules.h"
 
#include "../../include/arp_interface.h"
#include "../../include/byteorder.h"
#include "../../include/checksum.h"
#include "../../include/device.h"
#include "../../include/icmp_client.h"
#include "../../include/icmp_codes.h"
#include "../../include/icmp_interface.h"
#include "../../include/il_interface.h"
#include "../../include/in.h"
#include "../../include/in6.h"
#include "../../include/inet.h"
#include "../../include/ip_client.h"
#include "../../include/ip_interface.h"
#include "../../include/net_interface.h"
#include "../../include/nil_interface.h"
#include "../../include/tl_interface.h"
#include "../../include/socket_codes.h"
#include "../../include/socket_errno.h"
#include "../../structures/measured_strings.h"
#include "../../structures/module_map.h"
#include "../../structures/packet/packet_client.h"
 
#include "../../nil/nil_messages.h"
 
#include "../il_messages.h"
 
#include "ip.h"
#include "ip_header.h"
#include "ip_messages.h"
#include "ip_module.h"
 
/** IP version 4.
 */
#define IPV4                4
 
/** Default network interface IP version.
 */
#define NET_DEFAULT_IPV     IPV4
 
/** Default network interface IP routing.
 */
#define NET_DEFAULT_IP_ROUTING  false
 
/** Minimum IP packet content.
 */
#define IP_MIN_CONTENT  576
 
/** ARP module name.
 */
#define ARP_NAME                "arp"
 
/** ARP module filename.
 */
#define ARP_FILENAME            "/srv/arp"
 
/** IP packet address length.
 */
#define IP_ADDR                         sizeof( struct sockaddr_in6 )
 
/** IP packet prefix length.
 */
#define IP_PREFIX                       sizeof( ip_header_t )
 
/** IP packet suffix length.
 */
#define IP_SUFFIX                       0
 
/** IP packet maximum content length.
 */
#define IP_MAX_CONTENT                  65535
 
/** The IP localhost address.
 */
#define IPV4_LOCALHOST_ADDRESS  htonl(( 127 << 24 ) + 1 )
 
/** IP global data.
 */
ip_globals_t    ip_globals;
 
DEVICE_MAP_IMPLEMENT( ip_netifs, ip_netif_t )
 
INT_MAP_IMPLEMENT( ip_protos, ip_proto_t )
 
GENERIC_FIELD_IMPLEMENT( ip_routes, ip_route_t )
 
/** Updates the device content length according to the new MTU value.
 *  @param[in] device_id The device identifier.
 *  @param[in] mtu The new mtu value.
 *  @returns EOK on success.
 *  @returns ENOENT if device is not found.
 */
int ip_mtu_changed_message( device_id_t device_id, size_t mtu );
 
/** Updates the device state.
 *  @param[in] device_id The device identifier.
 *  @param[in] state The new state value.
 *  @returns EOK on success.
 *  @returns ENOENT if device is not found.
 */
int ip_device_state_message( device_id_t device_id, device_state_t state );
 
/** Registers the transport layer protocol.
 *  The traffic of this protocol will be supplied using either the receive function or IPC message.
 *  @param[in] protocol The transport layer module protocol.
 *  @param[in] service The transport layer module service.
 *  @param[in] phone The transport layer module phone.
 *  @param[in] tl_received_msg The receiving function.
 *  @returns EOK on success.
 *  @returns EINVAL if the protocol parameter and/or the service parameter is zero (0).
 *  @returns EINVAL if the phone parameter is not a positive number and the tl_receive_msg is NULL.
 *  @returns ENOMEM if there is not enough memory left.
 */
int ip_register( int protocol, services_t service, int phone, tl_received_msg_t tl_received_msg );
 
/** Initializes a new network interface specific data.
 *  Connects to the network interface layer module, reads the netif configuration, starts an ARP module if needed and sets the netif routing table.
 *  The device identifier and the nil service has to be set.
 *  @param[in,out] ip_netif Network interface specific data.
 *  @returns EOK on success.
 *  @returns ENOTSUP if DHCP is configured.
 *  @returns ENOTSUP if IPv6 is configured.
 *  @returns EINVAL if any of the addresses is invalid.
 *  @returns EINVAL if the used ARP module is not known.
 *  @returns ENOMEM if there is not enough memory left.
 *  @returns Other error codes as defined for the net_get_device_conf_req() function.
 *  @returns Other error codes as defined for the bind_service() function.
 *  @returns Other error codes as defined for the specific arp_device_req() function.
 *  @returns Other error codes as defined for the nil_packet_size_req() function.
 */
int ip_netif_initialize( ip_netif_ref ip_netif );
 
/** Sends the packet or the packet queue via the specified route.
 *  The ICMP_HOST_UNREACH error notification may be sent if route hardware destination address is found.
 *  @param[in,out] packet The packet to be sent.
 *  @param[in] netif The target network interface.
 *  @param[in] route The target route.
 *  @param[in] src The source address.
 *  @param[in] dest The destination address.
 *  @param[in] error The error module service.
 *  @returns EOK on success.
 *  @returns Other error codes as defined for the arp_translate_req() function.
 *  @returns Other error codes as defined for the ip_prepare_packet() function.
 */
int ip_send_route( packet_t packet, ip_netif_ref netif, ip_route_ref route, in_addr_t * src, in_addr_t dest, services_t error );
 
/** Prepares the outgoing packet or the packet queue.
 *  The packet queue is a fragmented packet
 *  Updates the first packet's IP header.
 *  Prefixes the additional packets with fragment headers.
 *  @param[in] source The source address.
 *  @param[in] dest The destination address.
 *  @param[in,out] packet The packet to be sent.
 *  @param[in] destination The destination hardware address.
 *  @returns EOK on success.
 *  @returns EINVAL if the packet is too small to contain the IP header.
 *  @returns EINVAL if the packet is too long than the IP allows.
 *  @returns ENOMEM if there is not enough memory left.
 *  @returns Other error codes as defined for the packet_set_addr() function.
 */
int ip_prepare_packet( in_addr_t * source, in_addr_t dest, packet_t packet, measured_string_ref destination );
 
/** Checks the packet queue lengths and fragments the packets if needed.
 *  The ICMP_FRAG_NEEDED error notification may be sent if the packet needs to be fragmented and the fragmentation is not allowed.
 *  @param[in,out] packet The packet or the packet queue to be checked.
 *  @param[in] prefix The minimum prefix size.
 *  @param[in] content The maximum content size.
 *  @param[in] suffix The minimum suffix size.
 *  @param[in] addr_len The minimum address length.
 *  @param[in] error The error module service.
 *  @returns The packet or the packet queue of the allowed length.
 *  @returns NULL if there are no packets left.
 */
packet_t    ip_split_packet( packet_t packet, size_t prefix, size_t content, size_t suffix, socklen_t addr_len, services_t error );
 
/** Checks the packet length and fragments it if needed.
 *  The new fragments are queued before the original packet.
 *  @param[in,out] packet The packet to be checked.
 *  @param[in] length The maximum packet length.
 *  @param[in] prefix The minimum prefix size.
 *  @param[in] suffix The minimum suffix size.
 *  @param[in] addr_len The minimum address length.
 *  @returns EOK on success.
 *  @returns EINVAL if the packet_get_addr() function fails.
 *  @returns EINVAL if the packet does not contain the IP header.
 *  @returns EPERM if the packet needs to be fragmented and the fragmentation is not allowed.
 *  @returns ENOMEM if there is not enough memory left.
 *  @returns ENOMEM if there is no packet available.
 *  @returns ENOMEM if the packet is too small to contain the IP header.
 *  @returns Other error codes as defined for the packet_trim() function.
 *  @returns Other error codes as defined for the ip_create_middle_header() function.
 *  @returns Other error codes as defined for the ip_fragment_packet_data() function.
 */
int ip_fragment_packet( packet_t packet, size_t length, size_t prefix, size_t suffix, socklen_t addr_len );
 
/** Fragments the packet from the end.
 *  @param[in] packet The packet to be fragmented.
 *  @param[in,out] new_packet The new packet fragment.
 *  @param[in,out] header The original packet header.
 *  @param[in,out] new_header The new packet fragment header.
 *  @param[in] length The new fragment length.
 *  @param[in] src The source address.
 *  @param[in] dest The destiantion address.
 *  @param[in] addrlen The address length.
 *  @returns EOK on success.
 *  @returns ENOMEM if the target packet is too small.
 *  @returns Other error codes as defined for the packet_set_addr() function.
 *  @returns Other error codes as defined for the pq_insert_after() function.
 */
int ip_fragment_packet_data( packet_t packet, packet_t new_packet, ip_header_ref header, ip_header_ref new_header, size_t length, const struct sockaddr * src, const struct sockaddr * dest, socklen_t addrlen );
 
/** Prefixes a middle fragment header based on the last fragment header to the packet.
 *  @param[in] packet The packet to be prefixed.
 *  @param[in] last The last header to be copied.
 *  @returns The prefixed middle header.
 *  @returns NULL on error.
 */
ip_header_ref   ip_create_middle_header( packet_t packet, ip_header_ref last );
 
/** Copies the fragment header.
 *  Copies only the header itself and relevant IP options.
 *  @param[out] last The created header.
 *  @param[in] first The original header to be copied.
 */
void ip_create_last_header( ip_header_ref last, ip_header_ref first );
 
/** Returns the network interface's IP address.
 *  @param[in] netif The network interface.
 *  @returns The IP address.
 *  @returns NULL if no IP address was found.
 */
in_addr_t * ip_netif_address( ip_netif_ref netif );
 
/** Searches all network interfaces if there is a suitable route.
 *  @param[in] destination The destination address.
 *  @returns The found route.
 *  @returns NULL if no route was found.
 */
ip_route_ref    ip_find_route( in_addr_t destination );
 
/** Searches the network interfaces if there is a suitable route.
 *  @param[in] netif The network interface to be searched for routes. May be NULL.
 *  @param[in] destination The destination address.
 *  @returns The found route.
 *  @returns NULL if no route was found.
 */
ip_route_ref    ip_netif_find_route( ip_netif_ref netif, in_addr_t destination );
 
/** Processes the received IP packet or the packet queue one by one.
 *  The packet is either passed to another module or released on error.
 *  @param[in] device_id The source device identifier.
 *  @param[in,out] packet The received packet.
 *  @returns EOK on success and the packet is no longer needed.
 *  @returns EINVAL if the packet is too small to carry the IP packet.
 *  @returns EINVAL if the received address lengths differs from the registered values.
 *  @returns ENOENT if the device is not found in the cache.
 *  @returns ENOENT if the protocol for the device is not found in the cache.
 *  @returns ENOMEM if there is not enough memory left.
 */
int ip_receive_message( device_id_t device_id, packet_t packet );
 
/** Processes the received packet.
 *  The packet is either passed to another module or released on error.
 *  The ICMP_PARAM_POINTER error notification may be sent if the checksum is invalid.
 *  The ICMP_EXC_TTL error notification may be sent if the TTL is less than two (2).
 *  The ICMP_HOST_UNREACH error notification may be sent if no route was found.
 *  The ICMP_HOST_UNREACH error notification may be sent if the packet is for another host and the routing is disabled.
 *  @param[in] device_id The source device identifier.
 *  @param[in] packet The received packet to be processed.
 *  @returns EOK on success.
 *  @returns EINVAL if the TTL is less than two (2).
 *  @returns EINVAL if the checksum is invalid.
 *  @returns EAFNOSUPPORT if the address family is not supported.
 *  @returns ENOENT if no route was found.
 *  @returns ENOENT if the packet is for another host and the routing is disabled.
 */
int ip_process_packet( device_id_t device_id, packet_t packet );
 
/** Returns the packet destination address from the IP header.
 *  @param[in] header The packet IP header to be read.
 *  @returns The packet destination address.
 */
in_addr_t   ip_get_destination( ip_header_ref header );
 
/** Delivers the packet to the local host.
 *  The packet is either passed to another module or released on error.
 *  The ICMP_PROT_UNREACH error notification may be sent if the protocol is not found.
 *  @param[in] device_id The source device identifier.
 *  @param[in] packet The packet to be delivered.
 *  @param[in] header The first packet IP header. May be NULL.
 *  @param[in] error The packet error service.
 *  @returns EOK on success.
 *  @returns ENOTSUP if the packet is a fragment.
 *  @returns EAFNOSUPPORT if the address family is not supported.
 *  @returns ENOENT if the target protocol is not found.
 *  @returns Other error codes as defined for the packet_set_addr() function.
 *  @returns Other error codes as defined for the packet_trim() function.
 *  @returns Other error codes as defined for the protocol specific tl_received_msg function.
 */
int ip_deliver_local( device_id_t device_id, packet_t packet, ip_header_ref header, services_t error );
 
/** Prepares the ICMP notification packet.
 *  Releases additional packets and keeps only the first one.
 *  All packets is released on error.
 *  @param[in] error The packet error service.
 *  @param[in] packet The packet or the packet queue to be reported as faulty.
 *  @param[in] header The first packet IP header. May be NULL.
 *  @returns The found ICMP phone.
 *  @returns EINVAL if the error parameter is set.
 *  @returns EINVAL if the ICMP phone is not found.
 *  @returns EINVAL if the ip_prepare_icmp() fails.
 */
int ip_prepare_icmp_and_get_phone( services_t error, packet_t packet, ip_header_ref header );
 
/** Returns the ICMP phone.
 *  Searches the registered protocols.
 *  @returns The found ICMP phone.
 *  @returns ENOENT if the ICMP is not registered.
 */
int ip_get_icmp_phone( void );
 
/** Prepares the ICMP notification packet.
 *  Releases additional packets and keeps only the first one.
 *  @param[in] packet The packet or the packet queue to be reported as faulty.
 *  @param[in] header The first packet IP header. May be NULL.
 *  @returns EOK on success.
 *  @returns EINVAL if there are no data in the packet.
 *  @returns EINVAL if the packet is a fragment.
 *  @returns ENOMEM if the packet is too short to contain the IP header.
 *  @returns EAFNOSUPPORT if the address family is not supported.
 *  @returns Other error codes as defined for the packet_set_addr().
 */
int ip_prepare_icmp( packet_t packet, ip_header_ref header );
 
/** Releases the packet and returns the result.
 *  @param[in] packet The packet queue to be released.
 *  @param[in] result The result to be returned.
 *  @return The result parameter.
 */
int ip_release_and_return( packet_t packet, int result );
 
int ip_initialize( async_client_conn_t client_connection ){
    ERROR_DECLARE;
 
    fibril_rwlock_initialize( & ip_globals.lock );
    fibril_rwlock_write_lock( & ip_globals.lock );
    fibril_rwlock_initialize( & ip_globals.protos_lock );
    fibril_rwlock_initialize( & ip_globals.netifs_lock );
    ip_globals.packet_counter = 0;
    ip_globals.gateway.address.s_addr = 0;
    ip_globals.gateway.netmask.s_addr = 0;
    ip_globals.gateway.gateway.s_addr = 0;
    ip_globals.gateway.netif = NULL;
    ERROR_PROPAGATE( ip_netifs_initialize( & ip_globals.netifs ));
    ERROR_PROPAGATE( ip_protos_initialize( & ip_globals.protos ));
    ip_globals.client_connection = client_connection;
    ERROR_PROPAGATE( modules_initialize( & ip_globals.modules ));
    ERROR_PROPAGATE( add_module( NULL, & ip_globals.modules, ARP_NAME, ARP_FILENAME, SERVICE_ARP, arp_task_get_id(), arp_connect_module ));
    fibril_rwlock_write_unlock( & ip_globals.lock );
    return EOK;
}
 
int ip_device_req( int il_phone, device_id_t device_id, services_t netif ){
    ERROR_DECLARE;
 
    ip_netif_ref    ip_netif;
    ip_route_ref    route;
    int             index;
    char *          data;
 
    ip_netif = ( ip_netif_ref ) malloc( sizeof( ip_netif_t ));
    if( ! ip_netif ) return ENOMEM;
    if( ERROR_OCCURRED( ip_routes_initialize( & ip_netif->routes ))){
        free( ip_netif );
        return ERROR_CODE;
    }
    ip_netif->device_id = device_id;
    ip_netif->service = netif;
    ip_netif->state = NETIF_STOPPED;
    fibril_rwlock_write_lock( & ip_globals.netifs_lock );
    if( ERROR_OCCURRED( ip_netif_initialize( ip_netif ))){
        fibril_rwlock_write_unlock( & ip_globals.netifs_lock );
        ip_routes_destroy( & ip_netif->routes );
        free( ip_netif );
        return ERROR_CODE;
    }
    if( ip_netif->arp ) ++ ip_netif->arp->usage;
    // print the settings
    printf( "New device registered:\n\tid\t= %d\n\tphone\t= %d\n\tIPV\t= %d\n", ip_netif->device_id, ip_netif->phone, ip_netif->ipv );
    printf( "\tconfiguration\t= %s\n", ip_netif->dhcp ? "dhcp" : "static" );
    // TODO ipv6 addresses
    data = ( char * ) malloc( INET_ADDRSTRLEN );
    if( data ){
        for( index = 0; index < ip_routes_count( & ip_netif->routes ); ++ index ){
            route = ip_routes_get_index( & ip_netif->routes, index );
            if( route ){
                printf( "\tRouting %d:\n", index );
                inet_ntop( AF_INET, ( uint8_t * ) & route->address.s_addr, data, INET_ADDRSTRLEN );
                printf( "\t\taddress\t= %s\n", data );
                inet_ntop( AF_INET, ( uint8_t * ) & route->netmask.s_addr, data, INET_ADDRSTRLEN );
                printf( "\t\tnetmask\t= %s\n", data );
                inet_ntop( AF_INET, ( uint8_t * ) & route->gateway.s_addr, data, INET_ADDRSTRLEN );
                printf( "\t\tgateway\t= %s\n", data );
            }
        }
        inet_ntop( AF_INET, ( uint8_t * ) & ip_netif->broadcast.s_addr, data, INET_ADDRSTRLEN );
        printf( "\t\tbroadcast\t= %s\n", data );
        free( data );
    }
    fibril_rwlock_write_unlock( & ip_globals.netifs_lock );
    return EOK;
}
 
int ip_netif_initialize( ip_netif_ref ip_netif ){
    ERROR_DECLARE;
 
    measured_string_t   names[] = {{ "IPV", 3 }, { "IP_CONFIG", 9 }, { "IP_ADDR", 7 }, { "IP_NETMASK", 10 }, { "IP_GATEWAY", 10 }, { "IP_BROADCAST", 12 }, { "ARP", 3 }, { "IP_ROUTING", 10 }};
    measured_string_ref configuration;
    size_t              count = sizeof( names ) / sizeof( measured_string_t );
    char *              data;
    measured_string_t   address;
    int                 index;
    ip_route_ref        route;
    in_addr_t           gateway;
 
    ip_netif->arp = NULL;
    route = NULL;
    ip_netif->ipv = NET_DEFAULT_IPV;
    ip_netif->dhcp = false;
    ip_netif->routing = NET_DEFAULT_IP_ROUTING;
    configuration = & names[ 0 ];
    // get configuration
    ERROR_PROPAGATE( net_get_device_conf_req( ip_globals.net_phone, ip_netif->device_id, & configuration, count, & data ));
    if( configuration ){
        if( configuration[ 0 ].value ){
            ip_netif->ipv = strtol( configuration[ 0 ].value, NULL, 0 );
        }
        ip_netif->dhcp = ! str_lcmp( configuration[ 1 ].value, "dhcp", configuration[ 1 ].length );
        if( ip_netif->dhcp ){
            // TODO dhcp
            net_free_settings( configuration, data );
            return ENOTSUP;
        }else if( ip_netif->ipv == IPV4 ){
            route = ( ip_route_ref ) malloc( sizeof( ip_route_t ));
            if( ! route ){
                net_free_settings( configuration, data );
                return ENOMEM;
            }
            route->address.s_addr = 0;
            route->netmask.s_addr = 0;
            route->gateway.s_addr = 0;
            route->netif = ip_netif;
            index = ip_routes_add( & ip_netif->routes, route );
            if( index < 0 ){
                net_free_settings( configuration, data );
                free( route );
                return index;
            }
            if( ERROR_OCCURRED( inet_pton( AF_INET, configuration[ 2 ].value, ( uint8_t * ) & route->address.s_addr ))
            || ERROR_OCCURRED( inet_pton( AF_INET, configuration[ 3 ].value, ( uint8_t * ) & route->netmask.s_addr ))
            || ( inet_pton( AF_INET, configuration[ 4 ].value, ( uint8_t * ) & gateway.s_addr ) == EINVAL )
            || ( inet_pton( AF_INET, configuration[ 5 ].value, ( uint8_t * ) & ip_netif->broadcast.s_addr ) == EINVAL )){
                net_free_settings( configuration, data );
                return EINVAL;
            }
        }else{
            // TODO ipv6 in separate module
            net_free_settings( configuration, data );
            return ENOTSUP;
        }
        if( configuration[ 6 ].value ){
            ip_netif->arp = get_running_module( & ip_globals.modules, configuration[ 6 ].value );
            if( ! ip_netif->arp ){
                printf( "Failed to start the arp %s\n", configuration[ 6 ].value );
                net_free_settings( configuration, data );
                return EINVAL;
            }
        }
        if( configuration[ 7 ].value ){
            ip_netif->routing = ( configuration[ 7 ].value[ 0 ] == 'y' );
        }
        net_free_settings( configuration, data );
    }
    // binds the netif service which also initializes the device
    ip_netif->phone = nil_bind_service( ip_netif->service, ( ipcarg_t ) ip_netif->device_id, SERVICE_IP, ip_globals.client_connection );
    if( ip_netif->phone < 0 ){
        printf( "Failed to contact the nil service %d\n", ip_netif->service );
        return ip_netif->phone;
    }
    // has to be after the device netif module initialization
    if( ip_netif->arp ){
        if( route ){
            address.value = ( char * ) & route->address.s_addr;
            address.length = CONVERT_SIZE( in_addr_t, char, 1 );
            ERROR_PROPAGATE( arp_device_req( ip_netif->arp->phone, ip_netif->device_id, SERVICE_IP, ip_netif->service, & address ));
        }else{
            ip_netif->arp = 0;
        }
    }
    // get packet dimensions
    ERROR_PROPAGATE( nil_packet_size_req( ip_netif->phone, ip_netif->device_id, & ip_netif->addr_len, & ip_netif->prefix, & ip_netif->content, & ip_netif->suffix ));
    if( ip_netif->content < IP_MIN_CONTENT ){
        printf( "Maximum transmission unit %d bytes is too small, at least %d bytes are needed\n", ip_netif->content, IP_MIN_CONTENT );
        ip_netif->content = IP_MIN_CONTENT;
    }
    index = ip_netifs_add( & ip_globals.netifs, ip_netif->device_id, ip_netif );
    if( index < 0 ) return index;
    if( gateway.s_addr ){
        // the default gateway
        ip_globals.gateway.address.s_addr = 0;
        ip_globals.gateway.netmask.s_addr = 0;
        ip_globals.gateway.gateway.s_addr = gateway.s_addr;
        ip_globals.gateway.netif = ip_netif;
    }
    return EOK;
}
 
int ip_mtu_changed_message( device_id_t device_id, size_t mtu ){
    ip_netif_ref    netif;
 
    fibril_rwlock_write_lock( & ip_globals.netifs_lock );
    netif = ip_netifs_find( & ip_globals.netifs, device_id );
    if( ! netif ){
        fibril_rwlock_write_unlock( & ip_globals.netifs_lock );
        return ENOENT;
    }
    netif->content = mtu;
    printf( "ip - device %d changed mtu to %d\n\n", device_id, mtu );
    fibril_rwlock_write_unlock( & ip_globals.netifs_lock );
    return EOK;
}
 
int ip_device_state_message( device_id_t device_id, device_state_t state ){
    ip_netif_ref    netif;
 
    fibril_rwlock_write_lock( & ip_globals.netifs_lock );
    // find the device
    netif = ip_netifs_find( & ip_globals.netifs, device_id );
    if( ! netif ){
        fibril_rwlock_write_unlock( & ip_globals.netifs_lock );
        return ENOENT;
    }
    netif->state = state;
    printf( "ip - device %d changed state to %d\n\n", device_id, state );
    fibril_rwlock_write_unlock( & ip_globals.netifs_lock );
    return EOK;
}
 
int ip_connect_module( services_t service ){
    return EOK;
}
 
int ip_bind_service( services_t service, int protocol, services_t me, async_client_conn_t receiver, tl_received_msg_t received_msg ){
    return ip_register( protocol, me, 0, received_msg );
}
 
int ip_register( int protocol, services_t service, int phone, tl_received_msg_t received_msg ){
    ip_proto_ref    proto;
    int             index;
 
    if( !( protocol && service && (( phone > 0 ) || ( received_msg )))) return EINVAL;
    proto = ( ip_proto_ref ) malloc( sizeof( ip_protos_t ));
    if( ! proto ) return ENOMEM;
    proto->protocol = protocol;
    proto->service = service;
    proto->phone = phone;
    proto->received_msg = received_msg;
    fibril_rwlock_write_lock( & ip_globals.protos_lock );
    index = ip_protos_add( & ip_globals.protos, proto->protocol, proto );
    if( index < 0 ){
        fibril_rwlock_write_unlock( & ip_globals.protos_lock );
        free( proto );
        return index;
    }
    printf( "New protocol registered:\n\tprotocol\t= %d\n\tphone\t= %d\n", proto->protocol, proto->phone );
    fibril_rwlock_write_unlock( & ip_globals.protos_lock );
    return EOK;
}
 
int ip_send_msg( int il_phone, device_id_t device_id, packet_t packet, services_t sender, services_t error ){
    ERROR_DECLARE;
 
    int                 addrlen;
    ip_netif_ref        netif;
    ip_route_ref        route;
    struct sockaddr *       addr;
    struct sockaddr_in *    address_in;
//  struct sockaddr_in6 *   address_in6;
    in_addr_t *         dest;
    in_addr_t *         src;
    int                 phone;
 
    // addresses in the host byte order
    // should be the next hop address or the target destination address
    addrlen = packet_get_addr( packet, NULL, ( uint8_t ** ) & addr );
    if( addrlen < 0 ){
        return ip_release_and_return( packet, addrlen );
    }
    if(( size_t ) addrlen < sizeof( struct sockaddr )){
        return ip_release_and_return( packet, EINVAL );
    }
    switch( addr->sa_family ){
        case AF_INET:
            if( addrlen != sizeof( struct sockaddr_in )){
                return ip_release_and_return( packet, EINVAL );
            }
            address_in = ( struct sockaddr_in * ) addr;
            dest = & address_in->sin_addr;
            break;
        // TODO IPv6
/*      case AF_INET6:
            if( addrlen != sizeof( struct sockaddr_in6 )) return EINVAL;
            address_in6 = ( struct sockaddr_in6 * ) dest;
            address_in6.sin6_addr.s6_addr;
*/      default:
            return ip_release_and_return( packet, EAFNOSUPPORT );
    }
    fibril_rwlock_read_lock( & ip_globals.netifs_lock );
    // device specified?
    if( device_id > 0 ){
        netif = ip_netifs_find( & ip_globals.netifs, device_id );
        route = ip_netif_find_route( netif, * dest );
        if( netif && ( ! route ) && ( ip_globals.gateway.netif == netif )){
            route = & ip_globals.gateway;
        }
    }else{
        route = ip_find_route( * dest );
        netif = route ? route->netif : NULL;
    }
    if( !( netif && route )){
        fibril_rwlock_read_unlock( & ip_globals.netifs_lock );
        phone = ip_prepare_icmp_and_get_phone( error, packet, NULL );
        if( phone >= 0 ){
            // unreachable ICMP if no routing
            icmp_destination_unreachable_msg( phone, ICMP_NET_UNREACH, 0, packet );
        }
        return ENOENT;
    }
    if( error ){
        // do not send for broadcast, anycast packets or network broadcast
        if(( ! dest->s_addr )
        || ( !( ~ dest->s_addr ))
        || ( !( ~(( dest->s_addr & ( ~ route->netmask.s_addr )) | route->netmask.s_addr )))
        || ( !( dest->s_addr & ( ~ route->netmask.s_addr )))){
            return ip_release_and_return( packet, EINVAL );
        }
    }
    if( route->address.s_addr == dest->s_addr ){
        // find the loopback device to deliver
        dest->s_addr = IPV4_LOCALHOST_ADDRESS;
        route = ip_find_route( * dest );
        netif = route ? route->netif : NULL;
        if( !( netif && route )){
            fibril_rwlock_read_unlock( & ip_globals.netifs_lock );
            phone = ip_prepare_icmp_and_get_phone( error, packet, NULL );
            if( phone >= 0 ){
                // unreachable ICMP if no routing
                icmp_destination_unreachable_msg( phone, ICMP_HOST_UNREACH, 0, packet );
            }
            return ENOENT;
        }
    }
    src = ip_netif_address( netif );
    if( ! src ){
        fibril_rwlock_read_unlock( & ip_globals.netifs_lock );
        return ip_release_and_return( packet, ENOENT );
    }
    ERROR_CODE = ip_send_route( packet, netif, route, src, * dest, error );
    fibril_rwlock_read_unlock( & ip_globals.netifs_lock );
    return ERROR_CODE;
}
 
in_addr_t * ip_netif_address( ip_netif_ref netif ){
    ip_route_ref    route;
 
    route = ip_routes_get_index( & netif->routes, 0 );
    return route ? & route->address : NULL;
}
 
int ip_send_route( packet_t packet, ip_netif_ref netif, ip_route_ref route, in_addr_t * src, in_addr_t dest, services_t error ){
    ERROR_DECLARE;
 
    measured_string_t   destination;
    measured_string_ref translation;
    char *              data;
    int                 phone;
 
    // get destination hardware address
    if( netif->arp && ( route->address.s_addr != dest.s_addr )){
        destination.value = route->gateway.s_addr ? ( char * ) & route->gateway.s_addr : ( char * ) & dest.s_addr;
        destination.length = CONVERT_SIZE( dest.s_addr, char, 1 );
        if( ERROR_OCCURRED( arp_translate_req( netif->arp->phone, netif->device_id, SERVICE_IP, & destination, & translation, & data ))){
//          sleep( 1 );
//          ERROR_PROPAGATE( arp_translate_req( netif->arp->phone, netif->device_id, SERVICE_IP, & destination, & translation, & data ));
            pq_release( ip_globals.net_phone, packet_get_id( packet ));
            return ERROR_CODE;
        }
        if( !( translation && translation->value )){
            if( translation ){
                free( translation );
                free( data );
            }
            phone = ip_prepare_icmp_and_get_phone( error, packet, NULL );
            if( phone >= 0 ){
                // unreachable ICMP if no routing
                icmp_destination_unreachable_msg( phone, ICMP_HOST_UNREACH, 0, packet );
            }
            return EINVAL;
        }
    }else translation = NULL;
    if( ERROR_OCCURRED( ip_prepare_packet( src, dest, packet, translation ))){
        pq_release( ip_globals.net_phone, packet_get_id( packet ));
    }else{
        packet = ip_split_packet( packet, netif->prefix, netif->content, netif->suffix, netif->addr_len, error );
        if( packet ){
            nil_send_msg( netif->phone, netif->device_id, packet, SERVICE_IP );
        }
    }
    if( translation ){
        free( translation );
        free( data );
    }
    return ERROR_CODE;
}
 
int ip_prepare_packet( in_addr_t * source, in_addr_t dest, packet_t packet, measured_string_ref destination ){
    ERROR_DECLARE;
 
    size_t              length;
    ip_header_ref       header;
    ip_header_ref       last_header;
    ip_header_ref       middle_header;
    packet_t            next;
 
    length = packet_get_data_length( packet );
    if(( length < sizeof( ip_header_t )) || ( length > IP_MAX_CONTENT )) return EINVAL;
    header = ( ip_header_ref ) packet_get_data( packet );
    if( destination ){
        ERROR_PROPAGATE( packet_set_addr( packet, NULL, ( uint8_t * ) destination->value, CONVERT_SIZE( char, uint8_t, destination->length )));
    }else{
        ERROR_PROPAGATE( packet_set_addr( packet, NULL, NULL, 0 ));
    }
    header->version = IPV4;
    header->fragment_offset_high = 0;
    header->fragment_offset_low = 0;
    header->header_checksum = 0;
    if( source ) header->source_address = source->s_addr;
    header->destination_address = dest.s_addr;
    fibril_rwlock_write_lock( & ip_globals.lock );
    ++ ip_globals.packet_counter;
    header->identification = htons( ip_globals.packet_counter );
    fibril_rwlock_write_unlock( & ip_globals.lock );
//  length = packet_get_data_length( packet );
    if( pq_next( packet )){
        last_header = ( ip_header_ref ) malloc( IP_HEADER_LENGTH( header ));
        if( ! last_header ) return ENOMEM;
        ip_create_last_header( last_header, header );
        next = pq_next( packet );
        while( pq_next( next )){
            middle_header = ( ip_header_ref ) packet_prefix( next, IP_HEADER_LENGTH( last_header ));
            if( ! middle_header ) return ENOMEM;
            memcpy( middle_header, last_header, IP_HEADER_LENGTH( last_header ));
            header->flags |= IPFLAG_MORE_FRAGMENTS;
            middle_header->total_length = htons( packet_get_data_length( next ));
            middle_header->fragment_offset_high = IP_COMPUTE_FRAGMENT_OFFSET_HIGH( length );
            middle_header->fragment_offset_low = IP_COMPUTE_FRAGMENT_OFFSET_LOW( length );
            middle_header->header_checksum = IP_HEADER_CHECKSUM( middle_header );
            if( destination ){
                ERROR_PROPAGATE( packet_set_addr( next, NULL, ( uint8_t * ) destination->value, CONVERT_SIZE( char, uint8_t, destination->length )));
            }
            length += packet_get_data_length( next );
            next = pq_next( next );
        }
        middle_header = ( ip_header_ref ) packet_prefix( next, IP_HEADER_LENGTH( last_header ));
        if( ! middle_header ) return ENOMEM;
        memcpy( middle_header, last_header, IP_HEADER_LENGTH( last_header ));
        middle_header->total_length = htons( packet_get_data_length( next ));
        middle_header->fragment_offset_high = IP_COMPUTE_FRAGMENT_OFFSET_HIGH( length );
        middle_header->fragment_offset_low = IP_COMPUTE_FRAGMENT_OFFSET_LOW( length );
        middle_header->header_checksum = IP_HEADER_CHECKSUM( middle_header );
        if( destination ){
            ERROR_PROPAGATE( packet_set_addr( next, NULL, ( uint8_t * ) destination->value, CONVERT_SIZE( char, uint8_t, destination->length )));
        }
        length += packet_get_data_length( next );
        free( last_header );
        header->flags |= IPFLAG_MORE_FRAGMENTS;
    }
    header->total_length = htons( length );
    // unnecessary for all protocols
    header->header_checksum = IP_HEADER_CHECKSUM( header );
    return EOK;
}
 
int ip_message( ipc_callid_t callid, ipc_call_t * call, ipc_call_t * answer, int * answer_count ){
    ERROR_DECLARE;
 
    packet_t                packet;
    struct sockaddr *       addr;
    size_t                  addrlen;
    ip_pseudo_header_ref    header;
    size_t                  headerlen;
 
    * answer_count = 0;
    switch( IPC_GET_METHOD( * call )){
        case IPC_M_PHONE_HUNGUP:
            return EOK;
        case NET_IL_DEVICE:
            return ip_device_req( 0, IPC_GET_DEVICE( call ), IPC_GET_SERVICE( call ));
        case IPC_M_CONNECT_TO_ME:
            return ip_register( IL_GET_PROTO( call ), IL_GET_SERVICE( call ), IPC_GET_PHONE( call ), NULL );
        case NET_IL_SEND:
            ERROR_PROPAGATE( packet_translate( ip_globals.net_phone, & packet, IPC_GET_PACKET( call )));
            return ip_send_msg( 0, IPC_GET_DEVICE( call ), packet, 0, IPC_GET_ERROR( call ));
        case NET_IL_DEVICE_STATE:
            return ip_device_state_message( IPC_GET_DEVICE( call ), IPC_GET_STATE( call ));
        case NET_IL_RECEIVED:
            ERROR_PROPAGATE( packet_translate( ip_globals.net_phone, & packet, IPC_GET_PACKET( call )));
            return ip_receive_message( IPC_GET_DEVICE( call ), packet );
        case NET_IP_RECEIVED_ERROR:
            ERROR_PROPAGATE( packet_translate( ip_globals.net_phone, & packet, IPC_GET_PACKET( call )));
            return ip_received_error_msg( 0, IPC_GET_DEVICE( call ), packet, IPC_GET_TARGET( call ), IPC_GET_ERROR( call ));
        case NET_IP_ADD_ROUTE:
            return ip_add_route_req( 0, IPC_GET_DEVICE( call ), IP_GET_ADDRESS( call ), IP_GET_NETMASK( call ), IP_GET_GATEWAY( call ));
        case NET_IP_SET_GATEWAY:
            return ip_set_gateway_req( 0, IPC_GET_DEVICE( call ), IP_GET_GATEWAY( call ));
        case NET_IP_GET_ROUTE:
            ERROR_PROPAGATE( data_receive(( void ** ) & addr, & addrlen ));
            ERROR_PROPAGATE( ip_get_route_req( 0, IP_GET_PROTOCOL( call ), addr, ( socklen_t ) addrlen, IPC_SET_DEVICE( answer ), & header, & headerlen ));
            * IP_SET_HEADERLEN( answer ) = headerlen;
            * answer_count = 2;
            if( ! ERROR_OCCURRED( data_reply( & headerlen, sizeof( headerlen )))){
                ERROR_CODE = data_reply( header, headerlen );
            }
            free( header );
            return ERROR_CODE;
        case NET_IL_PACKET_SPACE:
            ERROR_PROPAGATE( ip_packet_size_req( 0, IPC_GET_DEVICE( call ), IPC_SET_ADDR( answer ), IPC_SET_PREFIX( answer ), IPC_SET_CONTENT( answer ), IPC_SET_SUFFIX( answer )));
            * answer_count = 3;
            return EOK;
        case NET_IL_MTU_CHANGED:
            return ip_mtu_changed_message( IPC_GET_DEVICE( call ), IPC_GET_MTU( call ));
    }
    return ENOTSUP;
}
 
int ip_packet_size_req( int ip_phone, device_id_t device_id, size_t * addr_len, size_t * prefix, size_t * content, size_t * suffix ){
    ip_netif_ref    netif;
    int             index;
 
    if( !( addr_len && prefix && content && suffix )) return EBADMEM;
    * content = IP_MAX_CONTENT - IP_PREFIX;
    fibril_rwlock_read_lock( & ip_globals.netifs_lock );
    if( device_id < 0 ){
        * addr_len = IP_ADDR;
        * prefix = 0;
        * suffix = 0;
        for( index = ip_netifs_count( & ip_globals.netifs ) - 1; index >= 0; -- index ){
            netif = ip_netifs_get_index( & ip_globals.netifs, index );
            if( netif ){
                if( netif->addr_len > * addr_len ) * addr_len = netif->addr_len;
                if( netif->prefix > * prefix ) * prefix = netif->prefix;
                if( netif->suffix > * suffix ) * suffix = netif->suffix;
            }
        }
        * prefix = * prefix + IP_PREFIX;
        * suffix = * suffix + IP_SUFFIX;
    }else{
        netif = ip_netifs_find( & ip_globals.netifs, device_id );
        if( ! netif ){
            fibril_rwlock_read_unlock( & ip_globals.netifs_lock );
            return ENOENT;
        }
        * addr_len = ( netif->addr_len > IP_ADDR ) ? netif->addr_len : IP_ADDR;
        * prefix = netif->prefix + IP_PREFIX;
        * suffix = netif->suffix + IP_SUFFIX;
    }
    fibril_rwlock_read_unlock( & ip_globals.netifs_lock );
    return EOK;
}
 
int ip_add_route_req( int ip_phone, device_id_t device_id, in_addr_t address, in_addr_t netmask, in_addr_t gateway ){
    ip_route_ref    route;
    ip_netif_ref    netif;
    int             index;
 
    fibril_rwlock_write_lock( & ip_globals.netifs_lock );
    netif = ip_netifs_find( & ip_globals.netifs, device_id );
    if( ! netif ){
        fibril_rwlock_write_unlock( & ip_globals.netifs_lock );
        return ENOENT;
    }
    route = ( ip_route_ref ) malloc( sizeof( ip_route_t ));
    if( ! route ){
        fibril_rwlock_write_unlock( & ip_globals.netifs_lock );
        return ENOMEM;
    }
    route->address.s_addr = address.s_addr;
    route->netmask.s_addr = netmask.s_addr;
    route->gateway.s_addr = gateway.s_addr;
    route->netif = netif;
    index = ip_routes_add( & netif->routes, route );
    if( index < 0 ) free( route );
    fibril_rwlock_write_unlock( & ip_globals.netifs_lock );
    return index;
}
 
ip_route_ref ip_find_route( in_addr_t destination ){
    int             index;
    ip_route_ref    route;
    ip_netif_ref    netif;
 
    // start with the last netif - the newest one
    index = ip_netifs_count( & ip_globals.netifs ) - 1;
    while( index >= 0 ){
        netif = ip_netifs_get_index( & ip_globals.netifs, index );
        if( netif && ( netif->state == NETIF_ACTIVE )){
            route = ip_netif_find_route( netif, destination );
            if( route ) return route;
        }
        -- index;
    }
    return & ip_globals.gateway;
}
 
ip_route_ref ip_netif_find_route( ip_netif_ref netif, in_addr_t destination ){
    int             index;
    ip_route_ref    route;
 
    if( netif ){
        // start with the first one - the direct route
        for( index = 0; index < ip_routes_count( & netif->routes ); ++ index ){
            route = ip_routes_get_index( & netif->routes, index );
            if( route && (( route->address.s_addr & route->netmask.s_addr ) == ( destination.s_addr & route->netmask.s_addr ))){
                return route;
            }
        }
    }
    return NULL;
}
 
int ip_set_gateway_req( int ip_phone, device_id_t device_id, in_addr_t gateway ){
    ip_netif_ref    netif;
 
    fibril_rwlock_write_lock( & ip_globals.netifs_lock );
    netif = ip_netifs_find( & ip_globals.netifs, device_id );
    if( ! netif ){
        fibril_rwlock_write_unlock( & ip_globals.netifs_lock );
        return ENOENT;
    }
    ip_globals.gateway.address.s_addr = 0;
    ip_globals.gateway.netmask.s_addr = 0;
    ip_globals.gateway.gateway.s_addr = gateway.s_addr;
    ip_globals.gateway.netif = netif;
    fibril_rwlock_write_unlock( & ip_globals.netifs_lock );
    return EOK;
}
 
packet_t ip_split_packet( packet_t packet, size_t prefix, size_t content, size_t suffix, socklen_t addr_len, services_t error ){
    size_t          length;
    packet_t        next;
    packet_t        new_packet;
    int             result;
    int             phone;
 
    next = packet;
    // check all packets
    while( next ){
        length = packet_get_data_length( next );
        // too long?
        if( length > content ){
            result = ip_fragment_packet( next, content, prefix, suffix, addr_len );
            if( result != EOK ){
                new_packet = pq_detach( next );
                if( next == packet ){
                    // the new first packet of the queue
                    packet = new_packet;
                }
                // fragmentation needed?
                if( result == EPERM ){
                    phone = ip_prepare_icmp_and_get_phone( error, next, NULL );
                    if( phone >= 0 ){
                        // fragmentation necessary ICMP
                        icmp_destination_unreachable_msg( phone, ICMP_FRAG_NEEDED, content, next );
                    }
                }else{
                    pq_release( ip_globals.net_phone, packet_get_id( next ));
                }
                next = new_packet;
                continue;
            }
        }
        next = pq_next( next );
    }
    return packet;
}
 
int ip_fragment_packet( packet_t packet, size_t length, size_t prefix, size_t suffix, socklen_t addr_len ){
    ERROR_DECLARE;
 
    packet_t        new_packet;
    ip_header_ref   header;
    ip_header_ref   middle_header;
    ip_header_ref   last_header;
    struct sockaddr *       src;
    struct sockaddr *       dest;
    socklen_t       addrlen;
    int             result;
 
    result = packet_get_addr( packet, ( uint8_t ** ) & src, ( uint8_t ** ) & dest );
    if( result <= 0 ) return EINVAL;
    addrlen = ( socklen_t ) result;
    if( packet_get_data_length( packet ) <= sizeof( ip_header_t )) return ENOMEM;
    // get header
    header = ( ip_header_ref ) packet_get_data( packet );
    if( ! header ) return EINVAL;
    // fragmentation forbidden?
    if( header->flags & IPFLAG_DONT_FRAGMENT ){
        return EPERM;
    }
    // create the last fragment
    new_packet = packet_get_4( ip_globals.net_phone, prefix, length, suffix, (( addrlen > addr_len ) ? addrlen : addr_len ));
    if( ! new_packet ) return ENOMEM;
    // allocate as much as originally
    last_header = ( ip_header_ref ) packet_suffix( new_packet, IP_HEADER_LENGTH( header ));
    if( ! last_header ){
        return ip_release_and_return( packet, ENOMEM );
    }
    ip_create_last_header( last_header, header );
    // trim the unused space
    if( ERROR_OCCURRED( packet_trim( new_packet, 0, IP_HEADER_LENGTH( header ) - IP_HEADER_LENGTH( last_header )))){
        return ip_release_and_return( packet, ERROR_CODE );
    }
    // biggest multiple of 8 lower than content
    // TODO even fragmentation?
    length = length & ( ~ 0x7 );// ( content / 8 ) * 8
    if( ERROR_OCCURRED( ip_fragment_packet_data( packet, new_packet, header, last_header, (( IP_HEADER_DATA_LENGTH( header ) - (( length - IP_HEADER_LENGTH( header )) & ( ~ 0x7 ))) % (( length - IP_HEADER_LENGTH( last_header )) & ( ~ 0x7 ))), src, dest, addrlen ))){
        return ip_release_and_return( packet, ERROR_CODE );
    }
    // mark the first as fragmented
    header->flags |= IPFLAG_MORE_FRAGMENTS;
    // create middle framgents
    while( IP_TOTAL_LENGTH( header ) > length ){
        new_packet = packet_get_4( ip_globals.net_phone, prefix, length, suffix, (( addrlen >= addr_len ) ? addrlen : addr_len ));
        if( ! new_packet ) return ENOMEM;
        middle_header = ip_create_middle_header( new_packet, last_header );
        if( ! middle_header ){
            return ip_release_and_return( packet, ENOMEM );
        }
        if( ERROR_OCCURRED( ip_fragment_packet_data( packet, new_packet, header, middle_header, ( length - IP_HEADER_LENGTH( middle_header )) & ( ~ 0x7 ), src, dest, addrlen ))){
            return ip_release_and_return( packet, ERROR_CODE );
        }
    }
    // finish the first fragment
    header->header_checksum = IP_HEADER_CHECKSUM( header );
    return EOK;
}
 
int ip_fragment_packet_data( packet_t packet, packet_t new_packet, ip_header_ref header, ip_header_ref new_header, size_t length, const struct sockaddr * src, const struct sockaddr * dest, socklen_t addrlen ){
    ERROR_DECLARE;
 
    void *          data;
    size_t          offset;
 
    data = packet_suffix( new_packet, length );
    if( ! data ) return ENOMEM;
    memcpy( data, (( void * ) header ) + IP_TOTAL_LENGTH( header ) - length, length );
    ERROR_PROPAGATE( packet_trim( packet, 0, length ));
    header->total_length = htons( IP_TOTAL_LENGTH( header ) - length );
    new_header->total_length = htons( IP_HEADER_LENGTH( new_header ) + length );
    offset = IP_FRAGMENT_OFFSET( header ) + IP_HEADER_DATA_LENGTH( header );
    new_header->fragment_offset_high = IP_COMPUTE_FRAGMENT_OFFSET_HIGH( offset );
    new_header->fragment_offset_low = IP_COMPUTE_FRAGMENT_OFFSET_LOW( offset );
    new_header->header_checksum = IP_HEADER_CHECKSUM( new_header );
    ERROR_PROPAGATE( packet_set_addr( new_packet, ( const uint8_t * ) src, ( const uint8_t * ) dest, addrlen ));
    return pq_insert_after( packet, new_packet );
}
 
ip_header_ref ip_create_middle_header( packet_t packet, ip_header_ref last ){
    ip_header_ref   middle;
 
    middle = ( ip_header_ref ) packet_suffix( packet, IP_HEADER_LENGTH( last ));
    if( ! middle ) return NULL;
    memcpy( middle, last, IP_HEADER_LENGTH( last ));
    middle->flags |= IPFLAG_MORE_FRAGMENTS;
    return middle;
}
 
void ip_create_last_header( ip_header_ref last, ip_header_ref first ){
    ip_option_ref   option;
    size_t          next;
    size_t          length;
 
    // copy first itself
    memcpy( last, first, sizeof( ip_header_t ));
    length = sizeof( ip_header_t );
    next = sizeof( ip_header_t );
    // process all ip options
    while( next < first->header_length ){
        option = ( ip_option_ref ) ((( uint8_t * ) first ) + next );
        // skip end or noop
        if(( option->type == IPOPT_END ) || ( option->type == IPOPT_NOOP )){
            ++ next;
        }else{
            // copy if said so or skip
            if( IPOPT_COPIED( option->type )){
                memcpy((( uint8_t * ) last ) + length, (( uint8_t * ) first ) + next, option->length );
                length += option->length;
            }
            // next option
            next += option->length;
        }
    }
    // align 4 byte boundary
    if( length % 4 ){
        bzero((( uint8_t * ) last ) + length, 4 - ( length % 4 ));
        last->header_length = length / 4 + 1;
    }else{
        last->header_length = length / 4;
    }
    last->header_checksum = 0;
}
 
int ip_receive_message( device_id_t device_id, packet_t packet ){
    packet_t        next;
 
    do{
        next = pq_detach( packet );
        ip_process_packet( device_id, packet );
        packet = next;
    }while( packet );
    return EOK;
}
 
int ip_process_packet( device_id_t device_id, packet_t packet ){
    ERROR_DECLARE;
 
    ip_header_ref   header;
    in_addr_t       dest;
    ip_route_ref    route;
    int             phone;
    struct sockaddr *   addr;
    struct sockaddr_in  addr_in;
//  struct sockaddr_in  addr_in6;
    socklen_t       addrlen;
 
    header = ( ip_header_ref ) packet_get_data( packet );
    if( ! header ){
        return ip_release_and_return( packet, ENOMEM );
    }
    // checksum
    if(( header->header_checksum ) && ( IP_HEADER_CHECKSUM( header ))){
        phone = ip_prepare_icmp_and_get_phone( 0, packet, header );
        if( phone >= 0 ){
            // checksum error ICMP
            icmp_parameter_problem_msg( phone, ICMP_PARAM_POINTER, (( size_t ) (( void * ) & header->header_checksum )) - (( size_t ) (( void * ) header )), packet );
        }
        return EINVAL;
    }
    if( header->ttl <= 1 ){
        phone = ip_prepare_icmp_and_get_phone( 0, packet, header );
        if( phone >= 0 ){
            // ttl oxceeded ICMP
            icmp_time_exceeded_msg( phone, ICMP_EXC_TTL, packet );
        }
        return EINVAL;
    }
    // process ipopt and get destination
    dest = ip_get_destination( header );
    // set the addrination address
    switch( header->version ){
        case IPVERSION:
            addrlen = sizeof( addr_in );
            bzero( & addr_in, addrlen );
            addr_in.sin_family = AF_INET;
            memcpy( & addr_in.sin_addr.s_addr, & dest, sizeof( dest ));
            addr = ( struct sockaddr * ) & addr_in;
            break;
/*      case IPv6VERSION:
            addrlen = sizeof( dest_in6 );
            bzero( & dest_in6, addrlen );
            dest_in6.sin6_family = AF_INET6;
            memcpy( & dest_in6.sin6_addr.s6_addr, );
            dest = ( struct sockaddr * ) & dest_in;
            break;
*/      default:
            return ip_release_and_return( packet, EAFNOSUPPORT );
    }
    ERROR_PROPAGATE( packet_set_addr( packet, NULL, ( uint8_t * ) & addr, addrlen ));
    route = ip_find_route( dest );
    if( ! route ){
        phone = ip_prepare_icmp_and_get_phone( 0, packet, header );
        if( phone >= 0 ){
            // unreachable ICMP
            icmp_destination_unreachable_msg( phone, ICMP_HOST_UNREACH, 0, packet );
        }
        return ENOENT;
    }
    if( route->address.s_addr == dest.s_addr ){
        // local delivery
        return ip_deliver_local( device_id, packet, header, 0 );
    }else{
        // only if routing enabled
        if( route->netif->routing ){
            -- header->ttl;
            return ip_send_route( packet, route->netif, route, NULL, dest, 0 );
        }else{
            phone = ip_prepare_icmp_and_get_phone( 0, packet, header );
            if( phone >= 0 ){
                // unreachable ICMP if no routing
                icmp_destination_unreachable_msg( phone, ICMP_HOST_UNREACH, 0, packet );
            }
            return ENOENT;
        }
    }
}
 
int ip_received_error_msg( int ip_phone, device_id_t device_id, packet_t packet, services_t target, services_t error ){
    uint8_t *           data;
    int                 offset;
    icmp_type_t         type;
    icmp_code_t         code;
    ip_netif_ref        netif;
    measured_string_t   address;
    ip_route_ref        route;
    ip_header_ref       header;
 
    switch( error ){
        case SERVICE_ICMP:
            offset = icmp_client_process_packet( packet, & type, & code, NULL, NULL );
            if( offset < 0 ){
                return ip_release_and_return( packet, ENOMEM );
            }
            data = packet_get_data( packet );
            header = ( ip_header_ref )( data + offset );
            // destination host unreachable?
            if(( type == ICMP_DEST_UNREACH ) && ( code == ICMP_HOST_UNREACH )){
                fibril_rwlock_read_lock( & ip_globals.netifs_lock );
                netif = ip_netifs_find( & ip_globals.netifs, device_id );
                if( netif && netif->arp ){
                    route = ip_routes_get_index( & netif->routes, 0 );
                    // from the same network?
                    if( route && (( route->address.s_addr & route->netmask.s_addr ) == ( header->destination_address & route->netmask.s_addr ))){
                        // clear the ARP mapping if any
                        address.value = ( char * ) & header->destination_address;
                        address.length = CONVERT_SIZE( uint8_t, char, sizeof( header->destination_address ));
                        arp_clear_address_req( netif->arp->phone, netif->device_id, SERVICE_IP, & address );
                    }
                }
                fibril_rwlock_read_unlock( & ip_globals.netifs_lock );
            }
            break;
        default:
            return ip_release_and_return( packet, ENOTSUP );
    }
    return ip_deliver_local( device_id, packet, header, error );
}
 
int ip_deliver_local( device_id_t device_id, packet_t packet, ip_header_ref header, services_t error ){
    ERROR_DECLARE;
 
    ip_proto_ref    proto;
    int             phone;
    services_t      service;
    tl_received_msg_t   received_msg;
    struct sockaddr *   src;
    struct sockaddr *   dest;
    struct sockaddr_in  src_in;
    struct sockaddr_in  dest_in;
//  struct sockaddr_in  src_in6;
//  struct sockaddr_in  dest_in6;
    socklen_t       addrlen;
 
    if(( header->flags & IPFLAG_MORE_FRAGMENTS ) || IP_FRAGMENT_OFFSET( header )){
        // TODO fragmented
        return ENOTSUP;
    }else{
        switch( header->version ){
            case IPVERSION:
                addrlen = sizeof( src_in );
                bzero( & src_in, addrlen );
                src_in.sin_family = AF_INET;
                memcpy( & dest_in, & src_in, addrlen );
                memcpy( & src_in.sin_addr.s_addr, & header->source_address, sizeof( header->source_address ));
                memcpy( & dest_in.sin_addr.s_addr, & header->destination_address, sizeof( header->destination_address ));
                src = ( struct sockaddr * ) & src_in;
                dest = ( struct sockaddr * ) & dest_in;
                break;
/*          case IPv6VERSION:
                addrlen = sizeof( src_in6 );
                bzero( & src_in6, addrlen );
                src_in6.sin6_family = AF_INET6;
                memcpy( & dest_in6, & src_in6, addrlen );
                memcpy( & src_in6.sin6_addr.s6_addr, );
                memcpy( & dest_in6.sin6_addr.s6_addr, );
                src = ( struct sockaddr * ) & src_in;
                dest = ( struct sockaddr * ) & dest_in;
                break;
*/          default:
                return ip_release_and_return( packet, EAFNOSUPPORT );
        }
        if( ERROR_OCCURRED( packet_set_addr( packet, ( uint8_t * ) src, ( uint8_t * ) dest, addrlen ))){
            return ip_release_and_return( packet, ERROR_CODE );
        }
        // trim padding if present
        if(( ! error ) && ( IP_TOTAL_LENGTH( header ) < packet_get_data_length( packet ))){
            if( ERROR_OCCURRED( packet_trim( packet, 0, packet_get_data_length( packet ) - IP_TOTAL_LENGTH( header )))){
                return ip_release_and_return( packet, ERROR_CODE );
            }
        }
        fibril_rwlock_read_lock( & ip_globals.protos_lock );
        proto = ip_protos_find( & ip_globals.protos, header->protocol );
        if( ! proto ){
            fibril_rwlock_read_unlock( & ip_globals.protos_lock );
            phone = ip_prepare_icmp_and_get_phone( error, packet, header );
            if( phone >= 0 ){
                // unreachable ICMP
                icmp_destination_unreachable_msg( phone, ICMP_PROT_UNREACH, 0, packet );
            }
            return ENOENT;
        }
        if( proto->received_msg ){
            service = proto->service;
            received_msg = proto->received_msg;
            fibril_rwlock_read_unlock( & ip_globals.protos_lock );
            ERROR_CODE = received_msg( device_id, packet, service, error );
        }else{
            ERROR_CODE = tl_received_msg( proto->phone, device_id, packet, proto->service, error );
            fibril_rwlock_read_unlock( & ip_globals.protos_lock );
        }
        return ERROR_CODE;
    }
}
 
in_addr_t ip_get_destination( ip_header_ref header ){
    in_addr_t   destination;
 
    // TODO search set ipopt route?
    destination.s_addr = header->destination_address;
    return destination;
}
 
int ip_prepare_icmp( packet_t packet, ip_header_ref header ){
    packet_t    next;
    struct sockaddr *   dest;
    struct sockaddr_in  dest_in;
//  struct sockaddr_in  dest_in6;
    socklen_t       addrlen;
 
    // detach the first packet and release the others
    next = pq_detach( packet );
    if( next ){
        pq_release( ip_globals.net_phone, packet_get_id( next ));
    }
    if( ! header ){
        if( packet_get_data_length( packet ) <= sizeof( ip_header_t )) return ENOMEM;
        // get header
        header = ( ip_header_ref ) packet_get_data( packet );
        if( ! header ) return EINVAL;
    }
    // only for the first fragment
    if( IP_FRAGMENT_OFFSET( header )) return EINVAL;
    // set the destination address
    switch( header->version ){
        case IPVERSION:
            addrlen = sizeof( dest_in );
            bzero( & dest_in, addrlen );
            dest_in.sin_family = AF_INET;
            memcpy( & dest_in.sin_addr.s_addr, & header->source_address, sizeof( header->source_address ));
            dest = ( struct sockaddr * ) & dest_in;
            break;
/*      case IPv6VERSION:
            addrlen = sizeof( dest_in6 );
            bzero( & dest_in6, addrlen );
            dest_in6.sin6_family = AF_INET6;
            memcpy( & dest_in6.sin6_addr.s6_addr, );
            dest = ( struct sockaddr * ) & dest_in;
            break;
*/      default:
            return EAFNOSUPPORT;
    }
    return packet_set_addr( packet, NULL, ( uint8_t * ) dest, addrlen );
}
 
int ip_get_icmp_phone( void ){
    ip_proto_ref    proto;
    int             phone;
 
    fibril_rwlock_read_lock( & ip_globals.protos_lock );
    proto = ip_protos_find( & ip_globals.protos, IPPROTO_ICMP );
    phone = proto ? proto->phone : ENOENT;
    fibril_rwlock_read_unlock( & ip_globals.protos_lock );
    return phone;
}
 
int ip_prepare_icmp_and_get_phone( services_t error, packet_t packet, ip_header_ref header ){
    int phone;
 
    phone = ip_get_icmp_phone();
    if( error || ( phone < 0 ) || ip_prepare_icmp( packet, header )){
        return ip_release_and_return( packet, EINVAL );
    }
    return phone;
}
 
int ip_release_and_return( packet_t packet, int result ){
    pq_release( ip_globals.net_phone, packet_get_id( packet ));
    return result;
}
 
int ip_get_route_req( int ip_phone, ip_protocol_t protocol, const struct sockaddr * destination, socklen_t addrlen, device_id_t * device_id, ip_pseudo_header_ref * header, size_t * headerlen ){
    struct sockaddr_in *    address_in;
//  struct sockaddr_in6 *   address_in6;
    in_addr_t *             dest;
    in_addr_t *             src;
    ip_route_ref            route;
    ipv4_pseudo_header_ref  header_in;
 
    if( !( destination && ( addrlen > 0 ))) return EINVAL;
    if( !( device_id && header && headerlen )) return EBADMEM;
    if(( size_t ) addrlen < sizeof( struct sockaddr )){
        return EINVAL;
    }
    switch( destination->sa_family ){
        case AF_INET:
            if( addrlen != sizeof( struct sockaddr_in )){
                return EINVAL;
            }
            address_in = ( struct sockaddr_in * ) destination;
            dest = & address_in->sin_addr;
            break;
        // TODO IPv6
/*      case AF_INET6:
            if( addrlen != sizeof( struct sockaddr_in6 )) return EINVAL;
            address_in6 = ( struct sockaddr_in6 * ) dest;
            address_in6.sin6_addr.s6_addr;
*/      default:
            return EAFNOSUPPORT;
    }
    fibril_rwlock_read_lock( & ip_globals.lock );
    route = ip_find_route( * dest );
    if( !( route && route->netif )){
        fibril_rwlock_read_unlock( & ip_globals.lock );
        return ENOENT;
    }
    * device_id = route->netif->device_id;
    src = ip_netif_address( route->netif );
    fibril_rwlock_read_unlock( & ip_globals.lock );
    * headerlen = sizeof( * header_in );
    header_in = ( ipv4_pseudo_header_ref ) malloc( * headerlen );
    if( ! header_in ) return ENOMEM;
    bzero( header_in, * headerlen );
    header_in->destination_address = dest->s_addr;
    header_in->source_address = src->s_addr;
    header_in->protocol = protocol;
    header_in->data_length = 0;
    * header = ( ip_pseudo_header_ref ) header_in;
    return EOK;
}
 
/** @}
 */
 

Rev 4743	Rev 4756
1	/*	1	/*
2	* Copyright (c) 2009 Lukas Mejdrech	2	* Copyright (c) 2009 Lukas Mejdrech
3	* All rights reserved.	3	* All rights reserved.
4	*	4	*
5	* Redistribution and use in source and binary forms, with or without	5	* Redistribution and use in source and binary forms, with or without
6	* modification, are permitted provided that the following conditions	6	* modification, are permitted provided that the following conditions
7	* are met:	7	* are met:
8	*	8	*
9	* - Redistributions of source code must retain the above copyright	9	* - Redistributions of source code must retain the above copyright
10	* notice, this list of conditions and the following disclaimer.	10	* notice, this list of conditions and the following disclaimer.
11	* - Redistributions in binary form must reproduce the above copyright	11	* - Redistributions in binary form must reproduce the above copyright
12	* notice, this list of conditions and the following disclaimer in the	12	* notice, this list of conditions and the following disclaimer in the
13	* documentation and/or other materials provided with the distribution.	13	* documentation and/or other materials provided with the distribution.
14	* - The name of the author may not be used to endorse or promote products	14	* - The name of the author may not be used to endorse or promote products
15	* derived from this software without specific prior written permission.	15	* derived from this software without specific prior written permission.
16	*	16	*
17	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR	17	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES	18	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.	19	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,	20	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT	21	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,	22	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY	23	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT	24	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF	25	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.	26	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27	*/	27	*/
28		28
29	/** @addtogroup ip	29	/** @addtogroup ip
30	* @{	30	* @{
31	*/	31	*/
32		32
33	/** @file	33	/** @file
34	* IP module implementation.	34	* IP module implementation.
35	* @see arp.h	35	* @see arp.h
36	* \todo	-
37	*/	36	*/
38		37
39	#include <async.h>	38	#include <async.h>
40	#include <errno.h>	39	#include <errno.h>
41	#include <fibril_sync.h>	40	#include <fibril_sync.h>
42	#include <stdio.h>	41	#include <stdio.h>
43	#include <string.h>	42	#include <string.h>
44		43
45	#include <ipc/ipc.h>	44	#include <ipc/ipc.h>
46	#include <ipc/services.h>	45	#include <ipc/services.h>
47		46
48	#include <sys/types.h>	47	#include <sys/types.h>
49		48
50	#include "../../err.h"	49	#include "../../err.h"
51	#include "../../messages.h"	50	#include "../../messages.h"
52	#include "../../modules.h"	51	#include "../../modules.h"
53		52
54	#include "../../include/arp_interface.h"	53	#include "../../include/arp_interface.h"
55	#include "../../include/byteorder.h"	54	#include "../../include/byteorder.h"
56	#include "../../include/checksum.h"	55	#include "../../include/checksum.h"
57	#include "../../include/device.h"	56	#include "../../include/device.h"
58	#include "../../include/icmp_client.h"	57	#include "../../include/icmp_client.h"
59	#include "../../include/icmp_codes.h"	58	#include "../../include/icmp_codes.h"
60	#include "../../include/icmp_interface.h"	59	#include "../../include/icmp_interface.h"
61	#include "../../include/il_interface.h"	60	#include "../../include/il_interface.h"
62	#include "../../include/in.h"	61	#include "../../include/in.h"
63	#include "../../include/in6.h"	62	#include "../../include/in6.h"
64	#include "../../include/inet.h"	63	#include "../../include/inet.h"
65	#include "../../include/ip_client.h"	64	#include "../../include/ip_client.h"
66	#include "../../include/ip_interface.h"	65	#include "../../include/ip_interface.h"
67	#include "../../include/net_interface.h"	66	#include "../../include/net_interface.h"
68	#include "../../include/nil_interface.h"	67	#include "../../include/nil_interface.h"
69	#include "../../include/tl_interface.h"	68	#include "../../include/tl_interface.h"
70	#include "../../include/socket_codes.h"	69	#include "../../include/socket_codes.h"
71	#include "../../include/socket_errno.h"	70	#include "../../include/socket_errno.h"
72	#include "../../structures/measured_strings.h"	71	#include "../../structures/measured_strings.h"
73	#include "../../structures/module_map.h"	72	#include "../../structures/module_map.h"
74	#include "../../structures/packet/packet_client.h"	73	#include "../../structures/packet/packet_client.h"
75		74
76	#include "../../nil/nil_messages.h"	75	#include "../../nil/nil_messages.h"
77		76
78	#include "../il_messages.h"	77	#include "../il_messages.h"
79		78
80	#include "ip.h"	79	#include "ip.h"
81	#include "ip_header.h"	80	#include "ip_header.h"
82	#include "ip_messages.h"	81	#include "ip_messages.h"
83	#include "ip_module.h"	82	#include "ip_module.h"
84		83
85	/** IP version 4.	84	/** IP version 4.
86	*/	85	*/
87	#define IPV4 4	86	#define IPV4 4
88		87
89	/** Default network interface IP version.	88	/** Default network interface IP version.
90	*/	89	*/
91	#define NET_DEFAULT_IPV IPV4	90	#define NET_DEFAULT_IPV IPV4
92		91
93	/** Default network interface IP routing.	92	/** Default network interface IP routing.
94	*/	93	*/
95	#define NET_DEFAULT_IP_ROUTING false	94	#define NET_DEFAULT_IP_ROUTING false
96		95
97	/** Minimum IP packet content.	96	/** Minimum IP packet content.
98	*/	97	*/
99	#define IP_MIN_CONTENT 576	98	#define IP_MIN_CONTENT 576
100		99
101	/** ARP module name.	100	/** ARP module name.
102	*/	101	*/
103	#define ARP_NAME "arp"	102	#define ARP_NAME "arp"
104		103
105	/** ARP module filename.	104	/** ARP module filename.
106	*/	105	*/
107	#define ARP_FILENAME "/srv/arp"	106	#define ARP_FILENAME "/srv/arp"
108		107
109	/** IP packet address length.	108	/** IP packet address length.
110	*/	109	*/
111	#define IP_ADDR sizeof( struct sockaddr_in6 )	110	#define IP_ADDR sizeof( struct sockaddr_in6 )
112		111
113	/** IP packet prefix length.	112	/** IP packet prefix length.
114	*/	113	*/
115	#define IP_PREFIX sizeof( ip_header_t )	114	#define IP_PREFIX sizeof( ip_header_t )
116		115
117	/** IP packet suffix length.	116	/** IP packet suffix length.
118	*/	117	*/
119	#define IP_SUFFIX 0	118	#define IP_SUFFIX 0
120		119
121	/** IP packet maximum content length.	120	/** IP packet maximum content length.
122	*/	121	*/
123	#define IP_MAX_CONTENT 65535	122	#define IP_MAX_CONTENT 65535
124		123
125	/** The IP localhost address.	124	/** The IP localhost address.
126	*/	125	*/
127	#define IPV4_LOCALHOST_ADDRESS htonl(( 127 << 24 ) + 1 )	126	#define IPV4_LOCALHOST_ADDRESS htonl(( 127 << 24 ) + 1 )
128		127
129	/** IP global data.	128	/** IP global data.
130	*/	129	*/
131	ip_globals_t ip_globals;	130	ip_globals_t ip_globals;
132		131
133	DEVICE_MAP_IMPLEMENT( ip_netifs, ip_netif_t )	132	DEVICE_MAP_IMPLEMENT( ip_netifs, ip_netif_t )
134		133
135	INT_MAP_IMPLEMENT( ip_protos, ip_proto_t )	134	INT_MAP_IMPLEMENT( ip_protos, ip_proto_t )
136		135
137	GENERIC_FIELD_IMPLEMENT( ip_routes, ip_route_t )	136	GENERIC_FIELD_IMPLEMENT( ip_routes, ip_route_t )
138		137
139	/** Updates the device content length according to the new MTU value.	138	/** Updates the device content length according to the new MTU value.
140	* @param device_id The device identifier. Input parameter.	139	* @param[in] device_id The device identifier.
141	* @param mtu The new mtu value. Input parameter.	140	* @param[in] mtu The new mtu value.
142	* @returns EOK on success.	141	* @returns EOK on success.
143	* @returns ENOENT if device is not found.	142	* @returns ENOENT if device is not found.
144	*/	143	*/
145	int ip_mtu_changed_message( device_id_t device_id, size_t mtu );	144	int ip_mtu_changed_message( device_id_t device_id, size_t mtu );
146		145
147	/** Updates the device state.	146	/** Updates the device state.
148	* @param device_id The device identifier. Input parameter.	147	* @param[in] device_id The device identifier.
149	* @param state The new state value. Input parameter.	148	* @param[in] state The new state value.
150	* @returns EOK on success.	149	* @returns EOK on success.
151	* @returns ENOENT if device is not found.	150	* @returns ENOENT if device is not found.
152	*/	151	*/
153	int ip_device_state_message( device_id_t device_id, device_state_t state );	152	int ip_device_state_message( device_id_t device_id, device_state_t state );
154		153
-		154	/** Registers the transport layer protocol.
-		155	* The traffic of this protocol will be supplied using either the receive function or IPC message.
-		156	* @param[in] protocol The transport layer module protocol.
-		157	* @param[in] service The transport layer module service.
-		158	* @param[in] phone The transport layer module phone.
-		159	* @param[in] tl_received_msg The receiving function.
-		160	* @returns EOK on success.
-		161	* @returns EINVAL if the protocol parameter and/or the service parameter is zero (0).
-		162	* @returns EINVAL if the phone parameter is not a positive number and the tl_receive_msg is NULL.
-		163	* @returns ENOMEM if there is not enough memory left.
-		164	*/
155	int ip_register( int protocol, services_t service, int phone, tl_received_msg_t tl_received_msg );	165	int ip_register( int protocol, services_t service, int phone, tl_received_msg_t tl_received_msg );
156		166
157	/** Initializes a new network interface specific data.	167	/** Initializes a new network interface specific data.
158	* Connects to the network interface layer module, reads the netif configuration, starts an ARP module if needed and sets the netif routing table.	168	* Connects to the network interface layer module, reads the netif configuration, starts an ARP module if needed and sets the netif routing table.
159	* The device identifier and the nil service has to be set.	169	* The device identifier and the nil service has to be set.
160	* @param ip_netif Network interface specific data. Input/output parameter.	170	* @param[in,out] ip_netif Network interface specific data.
161	* @returns EOK on success.	171	* @returns EOK on success.
162	* @returns ENOTSUP if DHCP is configured.	172	* @returns ENOTSUP if DHCP is configured.
163	* @returns ENOTSUP if IPv6 is configured.	173	* @returns ENOTSUP if IPv6 is configured.
164	* @returns EINVAL if any of the addresses is invalid.	174	* @returns EINVAL if any of the addresses is invalid.
165	* @returns EINVAL if the used ARP module is not known.	175	* @returns EINVAL if the used ARP module is not known.
166	* @returns ENOMEM if there is not enough memory left.	176	* @returns ENOMEM if there is not enough memory left.
167	* @returns Other error codes as defined for the net_get_device_conf_req() function.	177	* @returns Other error codes as defined for the net_get_device_conf_req() function.
168	* @returns Other error codes as defined for the bind_service() function.	178	* @returns Other error codes as defined for the bind_service() function.
169	* @returns Other error codes as defined for the specific arp_device_req() function.	179	* @returns Other error codes as defined for the specific arp_device_req() function.
170	* @returns Other error codes as defined for the nil_packet_size_req() function.	180	* @returns Other error codes as defined for the nil_packet_size_req() function.
171	*/	181	*/
172	int ip_netif_initialize( ip_netif_ref ip_netif );	182	int ip_netif_initialize( ip_netif_ref ip_netif );
173		183
-		184	/** Sends the packet or the packet queue via the specified route.
-		185	* The ICMP_HOST_UNREACH error notification may be sent if route hardware destination address is found.
-		186	* @param[in,out] packet The packet to be sent.
-		187	* @param[in] netif The target network interface.
-		188	* @param[in] route The target route.
-		189	* @param[in] src The source address.
-		190	* @param[in] dest The destination address.
-		191	* @param[in] error The error module service.
-		192	* @returns EOK on success.
-		193	* @returns Other error codes as defined for the arp_translate_req() function.
-		194	* @returns Other error codes as defined for the ip_prepare_packet() function.
-		195	*/
174	int ip_send_route( packet_t packet, ip_netif_ref netif, ip_route_ref route, in_addr_t * src, in_addr_t dest, services_t error );	196	int ip_send_route( packet_t packet, ip_netif_ref netif, ip_route_ref route, in_addr_t * src, in_addr_t dest, services_t error );
-		197
-		198	/** Prepares the outgoing packet or the packet queue.
-		199	* The packet queue is a fragmented packet
-		200	* Updates the first packet's IP header.
-		201	* Prefixes the additional packets with fragment headers.
-		202	* @param[in] source The source address.
-		203	* @param[in] dest The destination address.
-		204	* @param[in,out] packet The packet to be sent.
-		205	* @param[in] destination The destination hardware address.
-		206	* @returns EOK on success.
-		207	* @returns EINVAL if the packet is too small to contain the IP header.
-		208	* @returns EINVAL if the packet is too long than the IP allows.
-		209	* @returns ENOMEM if there is not enough memory left.
-		210	* @returns Other error codes as defined for the packet_set_addr() function.
-		211	*/
175	int ip_prepare_packet( in_addr_t * source, in_addr_t dest, packet_t packet, measured_string_ref destination );	212	int ip_prepare_packet( in_addr_t * source, in_addr_t dest, packet_t packet, measured_string_ref destination );
176		213
-		214	/** Checks the packet queue lengths and fragments the packets if needed.
-		215	* The ICMP_FRAG_NEEDED error notification may be sent if the packet needs to be fragmented and the fragmentation is not allowed.
-		216	* @param[in,out] packet The packet or the packet queue to be checked.
-		217	* @param[in] prefix The minimum prefix size.
-		218	* @param[in] content The maximum content size.
-		219	* @param[in] suffix The minimum suffix size.
-		220	* @param[in] addr_len The minimum address length.
-		221	* @param[in] error The error module service.
-		222	* @returns The packet or the packet queue of the allowed length.
-		223	* @returns NULL if there are no packets left.
-		224	*/
177	packet_t ip_split_packet( packet_t packet, size_t prefix, size_t content, size_t suffix, socklen_t addr_len, services_t error );	225	packet_t ip_split_packet( packet_t packet, size_t prefix, size_t content, size_t suffix, socklen_t addr_len, services_t error );
-		226
-		227	/** Checks the packet length and fragments it if needed.
-		228	* The new fragments are queued before the original packet.
-		229	* @param[in,out] packet The packet to be checked.
-		230	* @param[in] length The maximum packet length.
-		231	* @param[in] prefix The minimum prefix size.
-		232	* @param[in] suffix The minimum suffix size.
-		233	* @param[in] addr_len The minimum address length.
-		234	* @returns EOK on success.
-		235	* @returns EINVAL if the packet_get_addr() function fails.
-		236	* @returns EINVAL if the packet does not contain the IP header.
-		237	* @returns EPERM if the packet needs to be fragmented and the fragmentation is not allowed.
-		238	* @returns ENOMEM if there is not enough memory left.
-		239	* @returns ENOMEM if there is no packet available.
-		240	* @returns ENOMEM if the packet is too small to contain the IP header.
-		241	* @returns Other error codes as defined for the packet_trim() function.
-		242	* @returns Other error codes as defined for the ip_create_middle_header() function.
-		243	* @returns Other error codes as defined for the ip_fragment_packet_data() function.
-		244	*/
178	int ip_fragment_packet( packet_t packet, size_t length, size_t prefix, size_t suffix, socklen_t addr_len );	245	int ip_fragment_packet( packet_t packet, size_t length, size_t prefix, size_t suffix, socklen_t addr_len );
-		246
-		247	/** Fragments the packet from the end.
-		248	* @param[in] packet The packet to be fragmented.
-		249	* @param[in,out] new_packet The new packet fragment.
-		250	* @param[in,out] header The original packet header.
-		251	* @param[in,out] new_header The new packet fragment header.
-		252	* @param[in] length The new fragment length.
-		253	* @param[in] src The source address.
-		254	* @param[in] dest The destiantion address.
-		255	* @param[in] addrlen The address length.
-		256	* @returns EOK on success.
-		257	* @returns ENOMEM if the target packet is too small.
-		258	* @returns Other error codes as defined for the packet_set_addr() function.
-		259	* @returns Other error codes as defined for the pq_insert_after() function.
-		260	*/
179	int ip_fragment_packet_data( packet_t packet, packet_t new_packet, ip_header_ref header, ip_header_ref new_header, size_t length, const struct sockaddr * src, const struct sockaddr * dest, socklen_t addrlen );	261	int ip_fragment_packet_data( packet_t packet, packet_t new_packet, ip_header_ref header, ip_header_ref new_header, size_t length, const struct sockaddr * src, const struct sockaddr * dest, socklen_t addrlen );
-		262
-		263	/** Prefixes a middle fragment header based on the last fragment header to the packet.
-		264	* @param[in] packet The packet to be prefixed.
-		265	* @param[in] last The last header to be copied.
-		266	* @returns The prefixed middle header.
-		267	* @returns NULL on error.
-		268	*/
180	ip_header_ref ip_create_middle_header( packet_t packet, ip_header_ref last );	269	ip_header_ref ip_create_middle_header( packet_t packet, ip_header_ref last );
-		270
-		271	/** Copies the fragment header.
-		272	* Copies only the header itself and relevant IP options.
-		273	* @param[out] last The created header.
-		274	* @param[in] first The original header to be copied.
-		275	*/
181	void ip_create_last_header( ip_header_ref last, ip_header_ref first );	276	void ip_create_last_header( ip_header_ref last, ip_header_ref first );
182		277
-		278	/** Returns the network interface's IP address.
-		279	* @param[in] netif The network interface.
-		280	* @returns The IP address.
-		281	* @returns NULL if no IP address was found.
-		282	*/
183	in_addr_t * ip_netif_address( ip_netif_ref netif );	283	in_addr_t * ip_netif_address( ip_netif_ref netif );
-		284
-		285	/** Searches all network interfaces if there is a suitable route.
-		286	* @param[in] destination The destination address.
-		287	* @returns The found route.
-		288	* @returns NULL if no route was found.
-		289	*/
184	ip_route_ref ip_find_route( in_addr_t destination );	290	ip_route_ref ip_find_route( in_addr_t destination );
-		291
-		292	/** Searches the network interfaces if there is a suitable route.
-		293	* @param[in] netif The network interface to be searched for routes. May be NULL.
-		294	* @param[in] destination The destination address.
-		295	* @returns The found route.
-		296	* @returns NULL if no route was found.
-		297	*/
185	ip_route_ref ip_netif_find_route( ip_netif_ref netif, in_addr_t destination );	298	ip_route_ref ip_netif_find_route( ip_netif_ref netif, in_addr_t destination );
186		299
187	/** Processes the received IP packet.	300	/** Processes the received IP packet or the packet queue one by one.
-		301	* The packet is either passed to another module or released on error.
188	* @param device_id The source device identifier. Input parameter.	302	* @param[in] device_id The source device identifier.
189	* @param packet The received packet. Input/output parameter.	303	* @param[in,out] packet The received packet.
190	* @returns EOK on success and the packet is no longer needed.	304	* @returns EOK on success and the packet is no longer needed.
191	* @returns EINVAL if the packet is too small to carry the IP packet.	305	* @returns EINVAL if the packet is too small to carry the IP packet.
192	* @returns EINVAL if the received address lengths differs from the registered values.	306	* @returns EINVAL if the received address lengths differs from the registered values.
193	* @returns ENOENT if the device is not found in the cache.	307	* @returns ENOENT if the device is not found in the cache.
194	* @returns ENOENT if the protocol for the device is not found in the cache.	308	* @returns ENOENT if the protocol for the device is not found in the cache.
195	* @returns ENOMEM if there is not enough memory left.	309	* @returns ENOMEM if there is not enough memory left.
196	*/	310	*/
197	int ip_receive_message( device_id_t device_id, packet_t packet );	311	int ip_receive_message( device_id_t device_id, packet_t packet );
198		312
-		313	/** Processes the received packet.
-		314	* The packet is either passed to another module or released on error.
-		315	* The ICMP_PARAM_POINTER error notification may be sent if the checksum is invalid.
-		316	* The ICMP_EXC_TTL error notification may be sent if the TTL is less than two (2).
-		317	* The ICMP_HOST_UNREACH error notification may be sent if no route was found.
-		318	* The ICMP_HOST_UNREACH error notification may be sent if the packet is for another host and the routing is disabled.
-		319	* @param[in] device_id The source device identifier.
-		320	* @param[in] packet The received packet to be processed.
-		321	* @returns EOK on success.
-		322	* @returns EINVAL if the TTL is less than two (2).
-		323	* @returns EINVAL if the checksum is invalid.
-		324	* @returns EAFNOSUPPORT if the address family is not supported.
-		325	* @returns ENOENT if no route was found.
-		326	* @returns ENOENT if the packet is for another host and the routing is disabled.
-		327	*/
199	int ip_process_packet( device_id_t device_id, packet_t packet );	328	int ip_process_packet( device_id_t device_id, packet_t packet );
-		329
-		330	/** Returns the packet destination address from the IP header.
-		331	* @param[in] header The packet IP header to be read.
-		332	* @returns The packet destination address.
-		333	*/
200	in_addr_t ip_get_destination( ip_header_ref header );	334	in_addr_t ip_get_destination( ip_header_ref header );
-		335
-		336	/** Delivers the packet to the local host.
-		337	* The packet is either passed to another module or released on error.
-		338	* The ICMP_PROT_UNREACH error notification may be sent if the protocol is not found.
-		339	* @param[in] device_id The source device identifier.
-		340	* @param[in] packet The packet to be delivered.
-		341	* @param[in] header The first packet IP header. May be NULL.
-		342	* @param[in] error The packet error service.
-		343	* @returns EOK on success.
-		344	* @returns ENOTSUP if the packet is a fragment.
-		345	* @returns EAFNOSUPPORT if the address family is not supported.
-		346	* @returns ENOENT if the target protocol is not found.
-		347	* @returns Other error codes as defined for the packet_set_addr() function.
-		348	* @returns Other error codes as defined for the packet_trim() function.
-		349	* @returns Other error codes as defined for the protocol specific tl_received_msg function.
-		350	*/
201	int ip_deliver_local( device_id_t device_id, packet_t packet, ip_header_ref header, services_t error );	351	int ip_deliver_local( device_id_t device_id, packet_t packet, ip_header_ref header, services_t error );
202		352
-		353	/** Prepares the ICMP notification packet.
-		354	* Releases additional packets and keeps only the first one.
-		355	* All packets is released on error.
-		356	* @param[in] error The packet error service.
-		357	* @param[in] packet The packet or the packet queue to be reported as faulty.
-		358	* @param[in] header The first packet IP header. May be NULL.
-		359	* @returns The found ICMP phone.
-		360	* @returns EINVAL if the error parameter is set.
-		361	* @returns EINVAL if the ICMP phone is not found.
-		362	* @returns EINVAL if the ip_prepare_icmp() fails.
-		363	*/
203	int ip_prepare_icmp_and_get_phone( services_t error, packet_t packet, ip_header_ref header );	364	int ip_prepare_icmp_and_get_phone( services_t error, packet_t packet, ip_header_ref header );
-		365
-		366	/** Returns the ICMP phone.
-		367	* Searches the registered protocols.
-		368	* @returns The found ICMP phone.
-		369	* @returns ENOENT if the ICMP is not registered.
-		370	*/
204	int ip_get_icmp_phone( void );	371	int ip_get_icmp_phone( void );
-		372
-		373	/** Prepares the ICMP notification packet.
-		374	* Releases additional packets and keeps only the first one.
-		375	* @param[in] packet The packet or the packet queue to be reported as faulty.
-		376	* @param[in] header The first packet IP header. May be NULL.
-		377	* @returns EOK on success.
-		378	* @returns EINVAL if there are no data in the packet.
-		379	* @returns EINVAL if the packet is a fragment.
-		380	* @returns ENOMEM if the packet is too short to contain the IP header.
-		381	* @returns EAFNOSUPPORT if the address family is not supported.
-		382	* @returns Other error codes as defined for the packet_set_addr().
-		383	*/
205	int ip_prepare_icmp( packet_t packet, ip_header_ref header );	384	int ip_prepare_icmp( packet_t packet, ip_header_ref header );
206		385
-		386	/** Releases the packet and returns the result.
-		387	* @param[in] packet The packet queue to be released.
-		388	* @param[in] result The result to be returned.
-		389	* @return The result parameter.
-		390	*/
207	int ip_release_and_return( packet_t packet, int result );	391	int ip_release_and_return( packet_t packet, int result );
208		392
209	int ip_initialize( async_client_conn_t client_connection ){	393	int ip_initialize( async_client_conn_t client_connection ){
210	ERROR_DECLARE;	394	ERROR_DECLARE;
211		395
212	fibril_rwlock_initialize( & ip_globals.lock );	396	fibril_rwlock_initialize( & ip_globals.lock );
213	fibril_rwlock_write_lock( & ip_globals.lock );	397	fibril_rwlock_write_lock( & ip_globals.lock );
214	fibril_rwlock_initialize( & ip_globals.protos_lock );	398	fibril_rwlock_initialize( & ip_globals.protos_lock );
215	fibril_rwlock_initialize( & ip_globals.netifs_lock );	399	fibril_rwlock_initialize( & ip_globals.netifs_lock );
216	ip_globals.packet_counter = 0;	400	ip_globals.packet_counter = 0;
217	ip_globals.gateway.address.s_addr = 0;	401	ip_globals.gateway.address.s_addr = 0;
218	ip_globals.gateway.netmask.s_addr = 0;	402	ip_globals.gateway.netmask.s_addr = 0;
219	ip_globals.gateway.gateway.s_addr = 0;	403	ip_globals.gateway.gateway.s_addr = 0;
220	ip_globals.gateway.netif = NULL;	404	ip_globals.gateway.netif = NULL;
221	ERROR_PROPAGATE( ip_netifs_initialize( & ip_globals.netifs ));	405	ERROR_PROPAGATE( ip_netifs_initialize( & ip_globals.netifs ));
222	ERROR_PROPAGATE( ip_protos_initialize( & ip_globals.protos ));	406	ERROR_PROPAGATE( ip_protos_initialize( & ip_globals.protos ));
223	ip_globals.client_connection = client_connection;	407	ip_globals.client_connection = client_connection;
224	ERROR_PROPAGATE( modules_initialize( & ip_globals.modules ));	408	ERROR_PROPAGATE( modules_initialize( & ip_globals.modules ));
225	ERROR_PROPAGATE( add_module( NULL, & ip_globals.modules, ARP_NAME, ARP_FILENAME, SERVICE_ARP, arp_task_get_id(), arp_connect_module ));	409	ERROR_PROPAGATE( add_module( NULL, & ip_globals.modules, ARP_NAME, ARP_FILENAME, SERVICE_ARP, arp_task_get_id(), arp_connect_module ));
226	fibril_rwlock_write_unlock( & ip_globals.lock );	410	fibril_rwlock_write_unlock( & ip_globals.lock );
227	return EOK;	411	return EOK;
228	}	412	}
229		413
230	int ip_device_req( int il_phone, device_id_t device_id, services_t netif ){	414	int ip_device_req( int il_phone, device_id_t device_id, services_t netif ){
231	ERROR_DECLARE;	415	ERROR_DECLARE;
232		416
233	ip_netif_ref ip_netif;	417	ip_netif_ref ip_netif;
234	ip_route_ref route;	418	ip_route_ref route;
235	int index;	419	int index;
236	char * data;	420	char * data;
237		421
238	ip_netif = ( ip_netif_ref ) malloc( sizeof( ip_netif_t ));	422	ip_netif = ( ip_netif_ref ) malloc( sizeof( ip_netif_t ));
239	if( ! ip_netif ) return ENOMEM;	423	if( ! ip_netif ) return ENOMEM;
240	if( ERROR_OCCURRED( ip_routes_initialize( & ip_netif->routes ))){	424	if( ERROR_OCCURRED( ip_routes_initialize( & ip_netif->routes ))){
241	free( ip_netif );	425	free( ip_netif );
242	return ERROR_CODE;	426	return ERROR_CODE;
243	}	427	}
244	ip_netif->device_id = device_id;	428	ip_netif->device_id = device_id;
245	ip_netif->service = netif;	429	ip_netif->service = netif;
246	ip_netif->state = NETIF_STOPPED;	430	ip_netif->state = NETIF_STOPPED;
247	fibril_rwlock_write_lock( & ip_globals.netifs_lock );	431	fibril_rwlock_write_lock( & ip_globals.netifs_lock );
248	if( ERROR_OCCURRED( ip_netif_initialize( ip_netif ))){	432	if( ERROR_OCCURRED( ip_netif_initialize( ip_netif ))){
249	fibril_rwlock_write_unlock( & ip_globals.netifs_lock );	433	fibril_rwlock_write_unlock( & ip_globals.netifs_lock );
250	ip_routes_destroy( & ip_netif->routes );	434	ip_routes_destroy( & ip_netif->routes );
251	free( ip_netif );	435	free( ip_netif );
252	return ERROR_CODE;	436	return ERROR_CODE;
253	}	437	}
254	if( ip_netif->arp ) ++ ip_netif->arp->usage;	438	if( ip_netif->arp ) ++ ip_netif->arp->usage;
255	// print the settings	439	// print the settings
256	printf( "New device registered:\n\tid\t= %d\n\tphone\t= %d\n\tIPV\t= %d\n", ip_netif->device_id, ip_netif->phone, ip_netif->ipv );	440	printf( "New device registered:\n\tid\t= %d\n\tphone\t= %d\n\tIPV\t= %d\n", ip_netif->device_id, ip_netif->phone, ip_netif->ipv );
257	printf( "\tconfiguration\t= %s\n", ip_netif->dhcp ? "dhcp" : "static" );	441	printf( "\tconfiguration\t= %s\n", ip_netif->dhcp ? "dhcp" : "static" );
258	// TODO ipv6 addresses	442	// TODO ipv6 addresses
259	data = ( char * ) malloc( INET_ADDRSTRLEN );	443	data = ( char * ) malloc( INET_ADDRSTRLEN );
260	if( data ){	444	if( data ){
261	for( index = 0; index < ip_routes_count( & ip_netif->routes ); ++ index ){	445	for( index = 0; index < ip_routes_count( & ip_netif->routes ); ++ index ){
262	route = ip_routes_get_index( & ip_netif->routes, index );	446	route = ip_routes_get_index( & ip_netif->routes, index );
263	if( route ){	447	if( route ){
264	printf( "\tRouting %d:\n", index );	448	printf( "\tRouting %d:\n", index );
265	inet_ntop( AF_INET, ( uint8_t * ) & route->address.s_addr, data, INET_ADDRSTRLEN );	449	inet_ntop( AF_INET, ( uint8_t * ) & route->address.s_addr, data, INET_ADDRSTRLEN );
266	printf( "\t\taddress\t= %s\n", data );	450	printf( "\t\taddress\t= %s\n", data );
267	inet_ntop( AF_INET, ( uint8_t * ) & route->netmask.s_addr, data, INET_ADDRSTRLEN );	451	inet_ntop( AF_INET, ( uint8_t * ) & route->netmask.s_addr, data, INET_ADDRSTRLEN );
268	printf( "\t\tnetmask\t= %s\n", data );	452	printf( "\t\tnetmask\t= %s\n", data );
269	inet_ntop( AF_INET, ( uint8_t * ) & route->gateway.s_addr, data, INET_ADDRSTRLEN );	453	inet_ntop( AF_INET, ( uint8_t * ) & route->gateway.s_addr, data, INET_ADDRSTRLEN );
270	printf( "\t\tgateway\t= %s\n", data );	454	printf( "\t\tgateway\t= %s\n", data );
271	}	455	}
272	}	456	}
273	inet_ntop( AF_INET, ( uint8_t * ) & ip_netif->broadcast.s_addr, data, INET_ADDRSTRLEN );	457	inet_ntop( AF_INET, ( uint8_t * ) & ip_netif->broadcast.s_addr, data, INET_ADDRSTRLEN );
274	printf( "\t\tbroadcast\t= %s\n", data );	458	printf( "\t\tbroadcast\t= %s\n", data );
275	free( data );	459	free( data );
276	}	460	}
277	fibril_rwlock_write_unlock( & ip_globals.netifs_lock );	461	fibril_rwlock_write_unlock( & ip_globals.netifs_lock );
278	return EOK;	462	return EOK;
279	}	463	}
280		464
281	int ip_netif_initialize( ip_netif_ref ip_netif ){	465	int ip_netif_initialize( ip_netif_ref ip_netif ){
282	ERROR_DECLARE;	466	ERROR_DECLARE;
283		467
284	measured_string_t names[] = {{ "IPV", 3 }, { "IP_CONFIG", 9 }, { "IP_ADDR", 7 }, { "IP_NETMASK", 10 }, { "IP_GATEWAY", 10 }, { "IP_BROADCAST", 12 }, { "ARP", 3 }, { "IP_ROUTING", 10 }};	468	measured_string_t names[] = {{ "IPV", 3 }, { "IP_CONFIG", 9 }, { "IP_ADDR", 7 }, { "IP_NETMASK", 10 }, { "IP_GATEWAY", 10 }, { "IP_BROADCAST", 12 }, { "ARP", 3 }, { "IP_ROUTING", 10 }};
285	measured_string_ref configuration;	469	measured_string_ref configuration;
286	size_t count = sizeof( names ) / sizeof( measured_string_t );	470	size_t count = sizeof( names ) / sizeof( measured_string_t );
287	char * data;	471	char * data;
288	measured_string_t address;	472	measured_string_t address;
289	int index;	473	int index;
290	ip_route_ref route;	474	ip_route_ref route;
291	in_addr_t gateway;	475	in_addr_t gateway;
292		476
293	ip_netif->arp = NULL;	477	ip_netif->arp = NULL;
294	route = NULL;	478	route = NULL;
295	ip_netif->ipv = NET_DEFAULT_IPV;	479	ip_netif->ipv = NET_DEFAULT_IPV;
296	ip_netif->dhcp = false;	480	ip_netif->dhcp = false;
297	ip_netif->routing = NET_DEFAULT_IP_ROUTING;	481	ip_netif->routing = NET_DEFAULT_IP_ROUTING;
298	configuration = & names[ 0 ];	482	configuration = & names[ 0 ];
299	// get configuration	483	// get configuration
300	ERROR_PROPAGATE( net_get_device_conf_req( ip_globals.net_phone, ip_netif->device_id, & configuration, count, & data ));	484	ERROR_PROPAGATE( net_get_device_conf_req( ip_globals.net_phone, ip_netif->device_id, & configuration, count, & data ));
301	if( configuration ){	485	if( configuration ){
302	if( configuration[ 0 ].value ){	486	if( configuration[ 0 ].value ){
303	ip_netif->ipv = strtol( configuration[ 0 ].value, NULL, 0 );	487	ip_netif->ipv = strtol( configuration[ 0 ].value, NULL, 0 );
304	}	488	}
305	ip_netif->dhcp = ! str_lcmp( configuration[ 1 ].value, "dhcp", configuration[ 1 ].length );	489	ip_netif->dhcp = ! str_lcmp( configuration[ 1 ].value, "dhcp", configuration[ 1 ].length );
306	if( ip_netif->dhcp ){	490	if( ip_netif->dhcp ){
307	// TODO dhcp	491	// TODO dhcp
308	net_free_settings( configuration, data );	492	net_free_settings( configuration, data );
309	return ENOTSUP;	493	return ENOTSUP;
310	}else if( ip_netif->ipv == IPV4 ){	494	}else if( ip_netif->ipv == IPV4 ){
311	route = ( ip_route_ref ) malloc( sizeof( ip_route_t ));	495	route = ( ip_route_ref ) malloc( sizeof( ip_route_t ));
312	if( ! route ){	496	if( ! route ){
313	net_free_settings( configuration, data );	497	net_free_settings( configuration, data );
314	return ENOMEM;	498	return ENOMEM;
315	}	499	}

Subversion Repositories HelenOS

(root)/branches/network/uspace/srv/net/il/ip/ip.c – Rev 4743 → 4756