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
 *  \todo
 */
 
#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/crc.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 device_id The device identifier. Input parameter.
 *  @param mtu The new mtu value. Input parameter.
 *  @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 device_id The device identifier. Input parameter.
 *  @param state The new state value. Input parameter.
 *  @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 );
 
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 ip_netif Network interface specific data. Input/output parameter.
 *  @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 );
 
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 );
int ip_prepare_packet( in_addr_t * source, in_addr_t dest, packet_t packet, measured_string_ref destination );
 
packet_t    ip_split_packet( packet_t packet, size_t prefix, size_t content, size_t suffix, socklen_t addr_len, services_t error );
int ip_fragment_packet( packet_t packet, size_t length, size_t prefix, size_t suffix, socklen_t addr_len );
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 );
ip_header_ref   ip_create_middle_header( packet_t packet, ip_header_ref last );
void ip_create_last_header( ip_header_ref last, ip_header_ref first );
 
in_addr_t * ip_netif_address( ip_netif_ref netif );
ip_route_ref    ip_find_route( in_addr_t destination );
ip_route_ref    ip_netif_find_route( ip_netif_ref netif, in_addr_t destination );
 
/** Processes the received IP packet.
 *  @param device_id The source device identifier. Input parameter.
 *  @param packet The received packet. Input/output parameter.
 *  @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 );
 
int ip_process_packet( device_id_t device_id, packet_t packet );
in_addr_t   ip_get_destination( ip_header_ref header );
int ip_deliver_local( device_id_t device_id, packet_t packet, ip_header_ref header, services_t error );
 
int ip_prepare_icmp_and_get_phone( services_t error, packet_t packet, ip_header_ref header );
int ip_get_icmp_phone( void );
int ip_prepare_icmp( packet_t packet, ip_header_ref header );
 
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( "\tbroadcast\t= %s\n", data );
        inet_ntop( AF_INET, ( uint8_t * ) & ip_netif->dns1, data, INET_ADDRSTRLEN );
        printf( "\tdns1\t= %s\n", data );
        inet_ntop( AF_INET, ( uint8_t * ) & ip_netif->dns2, data, INET_ADDRSTRLEN );
        printf( "\tdns2\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 }, { "NETMASK", 7 }, { "GATEWAY", 7 }, { "BROADCAST", 9 }, { "DNS1", 4 }, { "DNS2", 4 }, { "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 )
            || ( inet_pton( AF_INET, configuration[ 6 ].value, ( uint8_t * ) & ip_netif->dns1 ) == EINVAL )
            || ( inet_pton( AF_INET, configuration[ 7 ].value, ( uint8_t * ) & ip_netif->dns2 ) == EINVAL )){
                net_free_settings( configuration, data );
                return EINVAL;
            }
        }else{
            // TODO ipv6 in separate module
            net_free_settings( configuration, data );
            return ENOTSUP;
        }
        if( configuration[ 8 ].value ){
            ip_netif->arp = get_running_module( & ip_globals.modules, configuration[ 8 ].value );
            if( ! ip_netif->arp ){
                printf( "Failed to start the arp %s\n", configuration[ 8 ].value );
                net_free_settings( configuration, data );
                return EINVAL;
            }
        }
        if( configuration[ 9 ].value ){
            ip_netif->routing = ( configuration[ 9 ].value[ 0 ] == 'y' );
        }
        net_free_settings( configuration, data );
    }
    // binds the netif service which also initializes the device
    ip_netif->phone = bind_service( ip_netif->service, ( ipcarg_t ) ip_netif->device_id, SERVICE_IP, 0, 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( 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 );
    }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;
            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 );
    printf( "offset %d = %d + %d\n", 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 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 EAFNOSUPPORT;
        }
        ERROR_PROPAGATE( packet_set_addr( packet, ( uint8_t * ) src, ( uint8_t * ) dest, addrlen ));
        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( 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 4728	Rev 4731
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	36	* \todo
37	*/	37	*/
38		38
39	#include <async.h>	39	#include <async.h>
40	#include <errno.h>	40	#include <errno.h>
41	#include <fibril_sync.h>	41	#include <fibril_sync.h>
42	#include <stdio.h>	42	#include <stdio.h>
43	#include <string.h>	43	#include <string.h>
44		44
45	#include <ipc/ipc.h>	45	#include <ipc/ipc.h>
46	#include <ipc/services.h>	46	#include <ipc/services.h>
47		47
48	#include <sys/types.h>	48	#include <sys/types.h>
49		49
50	#include "../../err.h"	50	#include "../../err.h"
51	#include "../../messages.h"	51	#include "../../messages.h"
52	#include "../../modules.h"	52	#include "../../modules.h"
53		53
54	#include "../../include/arp_interface.h"	54	#include "../../include/arp_interface.h"
55	#include "../../include/byteorder.h"	55	#include "../../include/byteorder.h"
56	#include "../../include/crc.h"	56	#include "../../include/crc.h"
57	#include "../../include/device.h"	57	#include "../../include/device.h"
58	#include "../../include/icmp_client.h"	58	#include "../../include/icmp_client.h"
59	#include "../../include/icmp_codes.h"	59	#include "../../include/icmp_codes.h"
60	#include "../../include/icmp_interface.h"	60	#include "../../include/icmp_interface.h"
61	#include "../../include/il_interface.h"	61	#include "../../include/il_interface.h"
62	#include "../../include/in.h"	62	#include "../../include/in.h"
63	#include "../../include/in6.h"	63	#include "../../include/in6.h"
64	#include "../../include/inet.h"	64	#include "../../include/inet.h"
65	#include "../../include/ip_client.h"	65	#include "../../include/ip_client.h"
66	#include "../../include/ip_interface.h"	66	#include "../../include/ip_interface.h"
67	#include "../../include/net_interface.h"	67	#include "../../include/net_interface.h"
68	#include "../../include/nil_interface.h"	68	#include "../../include/nil_interface.h"
69	#include "../../include/tl_interface.h"	69	#include "../../include/tl_interface.h"
70	#include "../../include/socket_codes.h"	70	#include "../../include/socket_codes.h"
71	#include "../../include/socket_errno.h"	71	#include "../../include/socket_errno.h"
72	#include "../../structures/measured_strings.h"	72	#include "../../structures/measured_strings.h"
73	#include "../../structures/module_map.h"	73	#include "../../structures/module_map.h"
74	#include "../../structures/packet/packet_client.h"	74	#include "../../structures/packet/packet_client.h"
75		75
76	#include "../../nil/nil_messages.h"	76	#include "../../nil/nil_messages.h"
77		77
78	#include "../il_messages.h"	78	#include "../il_messages.h"
79		79
80	#include "ip.h"	80	#include "ip.h"
81	#include "ip_header.h"	81	#include "ip_header.h"
82	#include "ip_messages.h"	82	#include "ip_messages.h"
83	#include "ip_module.h"	83	#include "ip_module.h"
84		84
85	/** IP version 4.	85	/** IP version 4.
86	*/	86	*/
87	#define IPV4 4	87	#define IPV4 4
88		88
89	/** Default network interface IP version.	89	/** Default network interface IP version.
90	*/	90	*/
91	#define NET_DEFAULT_IPV IPV4	91	#define NET_DEFAULT_IPV IPV4
92		92
93	/** Default network interface IP routing.	93	/** Default network interface IP routing.
94	*/	94	*/
95	#define NET_DEFAULT_IP_ROUTING false	95	#define NET_DEFAULT_IP_ROUTING false
96		96
97	/** Minimum IP packet content.	97	/** Minimum IP packet content.
98	*/	98	*/
99	#define IP_MIN_CONTENT 576	99	#define IP_MIN_CONTENT 576
100		100
101	/** ARP module name.	101	/** ARP module name.
102	*/	102	*/
103	#define ARP_NAME "arp"	103	#define ARP_NAME "arp"
104		104
105	/** ARP module filename.	105	/** ARP module filename.
106	*/	106	*/
107	#define ARP_FILENAME "/srv/arp"	107	#define ARP_FILENAME "/srv/arp"
108		108
109	/** IP packet address length.	109	/** IP packet address length.
110	*/	110	*/
111	#define IP_ADDR sizeof( struct sockaddr_in6 )	111	#define IP_ADDR sizeof( struct sockaddr_in6 )
112		112
113	/** IP packet prefix length.	113	/** IP packet prefix length.
114	*/	114	*/
115	#define IP_PREFIX sizeof( ip_header_t )	115	#define IP_PREFIX sizeof( ip_header_t )
116		116
117	/** IP packet suffix length.	117	/** IP packet suffix length.
118	*/	118	*/
119	#define IP_SUFFIX 0	119	#define IP_SUFFIX 0
120		120
121	/** IP packet maximum content length.	121	/** IP packet maximum content length.
122	*/	122	*/
123	#define IP_MAX_CONTENT 65535	123	#define IP_MAX_CONTENT 65535
124		124
125	/** The IP localhost address.	125	/** The IP localhost address.
126	*/	126	*/
127	#define IPV4_LOCALHOST_ADDRESS htonl(( 127 << 24 ) + 1 )	127	#define IPV4_LOCALHOST_ADDRESS htonl(( 127 << 24 ) + 1 )
128		128
129	/** IP global data.	129	/** IP global data.
130	*/	130	*/
131	ip_globals_t ip_globals;	131	ip_globals_t ip_globals;
132		132
133	DEVICE_MAP_IMPLEMENT( ip_netifs, ip_netif_t )	133	DEVICE_MAP_IMPLEMENT( ip_netifs, ip_netif_t )
134		134
135	INT_MAP_IMPLEMENT( ip_protos, ip_proto_t )	135	INT_MAP_IMPLEMENT( ip_protos, ip_proto_t )
136		136
137	GENERIC_FIELD_IMPLEMENT( ip_routes, ip_route_t )	137	GENERIC_FIELD_IMPLEMENT( ip_routes, ip_route_t )
138		138
139	/** Updates the device content length according to the new MTU value.	139	/** Updates the device content length according to the new MTU value.
140	* @param device_id The device identifier. Input parameter.	140	* @param device_id The device identifier. Input parameter.
141	* @param mtu The new mtu value. Input parameter.	141	* @param mtu The new mtu value. Input parameter.
142	* @returns EOK on success.	142	* @returns EOK on success.
143	* @returns ENOENT if device is not found.	143	* @returns ENOENT if device is not found.
144	*/	144	*/
145	int ip_mtu_changed_message( device_id_t device_id, size_t mtu );	145	int ip_mtu_changed_message( device_id_t device_id, size_t mtu );
146		146
147	/** Updates the device state.	147	/** Updates the device state.
148	* @param device_id The device identifier. Input parameter.	148	* @param device_id The device identifier. Input parameter.
149	* @param state The new state value. Input parameter.	149	* @param state The new state value. Input parameter.
150	* @returns EOK on success.	150	* @returns EOK on success.
151	* @returns ENOENT if device is not found.	151	* @returns ENOENT if device is not found.
152	*/	152	*/
153	int ip_device_state_message( device_id_t device_id, device_state_t state );	153	int ip_device_state_message( device_id_t device_id, device_state_t state );
154		154
155	int ip_register( int protocol, services_t service, int phone, tl_received_msg_t tl_received_msg );	155	int ip_register( int protocol, services_t service, int phone, tl_received_msg_t tl_received_msg );
156		156
157	/** Initializes a new network interface specific data.	157	/** 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.	158	* 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.	159	* The device identifier and the nil service has to be set.
160	* @param ip_netif Network interface specific data. Input/output parameter.	160	* @param ip_netif Network interface specific data. Input/output parameter.
161	* @returns EOK on success.	161	* @returns EOK on success.
162	* @returns ENOTSUP if DHCP is configured.	162	* @returns ENOTSUP if DHCP is configured.
163	* @returns ENOTSUP if IPv6 is configured.	163	* @returns ENOTSUP if IPv6 is configured.
164	* @returns EINVAL if any of the addresses is invalid.	164	* @returns EINVAL if any of the addresses is invalid.
165	* @returns EINVAL if the used ARP module is not known.	165	* @returns EINVAL if the used ARP module is not known.
166	* @returns ENOMEM if there is not enough memory left.	166	* @returns ENOMEM if there is not enough memory left.
167	* @returns Other error codes as defined for the net_get_device_conf_req() function.	167	* @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.	168	* @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.	169	* @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.	170	* @returns Other error codes as defined for the nil_packet_size_req() function.
171	*/	171	*/
172	int ip_netif_initialize( ip_netif_ref ip_netif );	172	int ip_netif_initialize( ip_netif_ref ip_netif );
173		173
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 );	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 );
175	int ip_prepare_packet( in_addr_t * source, in_addr_t dest, packet_t packet, measured_string_ref destination );	175	int ip_prepare_packet( in_addr_t * source, in_addr_t dest, packet_t packet, measured_string_ref destination );
176		176
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 );	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 );
178	int ip_fragment_packet( packet_t packet, size_t length, size_t prefix, size_t suffix, socklen_t addr_len );	178	int ip_fragment_packet( packet_t packet, size_t length, size_t prefix, size_t suffix, socklen_t addr_len );
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 );	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 );
180	ip_header_ref ip_create_middle_header( packet_t packet, ip_header_ref last );	180	ip_header_ref ip_create_middle_header( packet_t packet, ip_header_ref last );
181	void ip_create_last_header( ip_header_ref last, ip_header_ref first );	181	void ip_create_last_header( ip_header_ref last, ip_header_ref first );
182		182
183	in_addr_t * ip_netif_address( ip_netif_ref netif );	183	in_addr_t * ip_netif_address( ip_netif_ref netif );
184	ip_route_ref ip_find_route( in_addr_t destination );	184	ip_route_ref ip_find_route( in_addr_t destination );
185	ip_route_ref ip_netif_find_route( ip_netif_ref netif, in_addr_t destination );	185	ip_route_ref ip_netif_find_route( ip_netif_ref netif, in_addr_t destination );
186		186
187	/** Processes the received IP packet.	187	/** Processes the received IP packet.
188	* @param device_id The source device identifier. Input parameter.	188	* @param device_id The source device identifier. Input parameter.
189	* @param packet The received packet. Input/output parameter.	189	* @param packet The received packet. Input/output parameter.
190	* @returns EOK on success and the packet is no longer needed.	190	* @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.	191	* @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.	192	* @returns EINVAL if the received address lengths differs from the registered values.
193	* @returns ENOENT if the device is not found in the cache.	193	* @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.	194	* @returns ENOENT if the protocol for the device is not found in the cache.
195	* @returns ENOMEM if there is not enough memory left.	195	* @returns ENOMEM if there is not enough memory left.
196	*/	196	*/
197	int ip_receive_message( device_id_t device_id, packet_t packet );	197	int ip_receive_message( device_id_t device_id, packet_t packet );
198		198
199	int ip_process_packet( device_id_t device_id, packet_t packet );	199	int ip_process_packet( device_id_t device_id, packet_t packet );
200	in_addr_t ip_get_destination( ip_header_ref header );	200	in_addr_t ip_get_destination( ip_header_ref header );
201	int ip_deliver_local( device_id_t device_id, packet_t packet, ip_header_ref header, services_t error );	201	int ip_deliver_local( device_id_t device_id, packet_t packet, ip_header_ref header, services_t error );
202		202
203	int ip_prepare_icmp_and_get_phone( services_t error, packet_t packet, ip_header_ref header );	203	int ip_prepare_icmp_and_get_phone( services_t error, packet_t packet, ip_header_ref header );
204	int ip_get_icmp_phone( void );	204	int ip_get_icmp_phone( void );
205	int ip_prepare_icmp( packet_t packet, ip_header_ref header );	205	int ip_prepare_icmp( packet_t packet, ip_header_ref header );
206		206
207	int ip_release_and_return( packet_t packet, int result );	207	int ip_release_and_return( packet_t packet, int result );
208		208
209	int ip_initialize( async_client_conn_t client_connection ){	209	int ip_initialize( async_client_conn_t client_connection ){
210	ERROR_DECLARE;	210	ERROR_DECLARE;
211		211
212	fibril_rwlock_initialize( & ip_globals.lock );	212	fibril_rwlock_initialize( & ip_globals.lock );
213	fibril_rwlock_write_lock( & ip_globals.lock );	213	fibril_rwlock_write_lock( & ip_globals.lock );
214	fibril_rwlock_initialize( & ip_globals.protos_lock );	214	fibril_rwlock_initialize( & ip_globals.protos_lock );
215	fibril_rwlock_initialize( & ip_globals.netifs_lock );	215	fibril_rwlock_initialize( & ip_globals.netifs_lock );
216	ip_globals.packet_counter = 0;	216	ip_globals.packet_counter = 0;
217	ip_globals.gateway.address.s_addr = 0;	217	ip_globals.gateway.address.s_addr = 0;
218	ip_globals.gateway.netmask.s_addr = 0;	218	ip_globals.gateway.netmask.s_addr = 0;
219	ip_globals.gateway.gateway.s_addr = 0;	219	ip_globals.gateway.gateway.s_addr = 0;
220	ip_globals.gateway.netif = NULL;	220	ip_globals.gateway.netif = NULL;
221	ERROR_PROPAGATE( ip_netifs_initialize( & ip_globals.netifs ));	221	ERROR_PROPAGATE( ip_netifs_initialize( & ip_globals.netifs ));
222	ERROR_PROPAGATE( ip_protos_initialize( & ip_globals.protos ));	222	ERROR_PROPAGATE( ip_protos_initialize( & ip_globals.protos ));
223	ip_globals.client_connection = client_connection;	223	ip_globals.client_connection = client_connection;
224	ERROR_PROPAGATE( modules_initialize( & ip_globals.modules ));	224	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 ));	225	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 );	226	fibril_rwlock_write_unlock( & ip_globals.lock );
227	return EOK;	227	return EOK;
228	}	228	}
229		229
230	int ip_device_req( int il_phone, device_id_t device_id, services_t netif ){	230	int ip_device_req( int il_phone, device_id_t device_id, services_t netif ){
231	ERROR_DECLARE;	231	ERROR_DECLARE;
232		232
233	ip_netif_ref ip_netif;	233	ip_netif_ref ip_netif;
234	ip_route_ref route;	234	ip_route_ref route;
235	int index;	235	int index;
236	char * data;	236	char * data;
237		237
238	ip_netif = ( ip_netif_ref ) malloc( sizeof( ip_netif_t ));	238	ip_netif = ( ip_netif_ref ) malloc( sizeof( ip_netif_t ));
239	if( ! ip_netif ) return ENOMEM;	239	if( ! ip_netif ) return ENOMEM;
240	if( ERROR_OCCURRED( ip_routes_initialize( & ip_netif->routes ))){	240	if( ERROR_OCCURRED( ip_routes_initialize( & ip_netif->routes ))){
241	free( ip_netif );	241	free( ip_netif );
242	return ERROR_CODE;	242	return ERROR_CODE;
243	}	243	}
244	ip_netif->device_id = device_id;	244	ip_netif->device_id = device_id;
245	ip_netif->service = netif;	245	ip_netif->service = netif;
246	ip_netif->state = NETIF_STOPPED;	246	ip_netif->state = NETIF_STOPPED;
247	fibril_rwlock_write_lock( & ip_globals.netifs_lock );	247	fibril_rwlock_write_lock( & ip_globals.netifs_lock );
248	if( ERROR_OCCURRED( ip_netif_initialize( ip_netif ))){	248	if( ERROR_OCCURRED( ip_netif_initialize( ip_netif ))){
249	fibril_rwlock_write_unlock( & ip_globals.netifs_lock );	249	fibril_rwlock_write_unlock( & ip_globals.netifs_lock );
250	ip_routes_destroy( & ip_netif->routes );	250	ip_routes_destroy( & ip_netif->routes );
251	free( ip_netif );	251	free( ip_netif );
252	return ERROR_CODE;	252	return ERROR_CODE;
253	}	253	}
254	if( ip_netif->arp ) ++ ip_netif->arp->usage;	254	if( ip_netif->arp ) ++ ip_netif->arp->usage;
255	// print the settings	255	// 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 );	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 );
257	printf( "\tconfiguration\t= %s\n", ip_netif->dhcp ? "dhcp" : "static" );	257	printf( "\tconfiguration\t= %s\n", ip_netif->dhcp ? "dhcp" : "static" );
258	// TODO ipv6 addresses	258	// TODO ipv6 addresses
259	data = ( char * ) malloc( INET_ADDRSTRLEN );	259	data = ( char * ) malloc( INET_ADDRSTRLEN );
260	if( data ){	260	if( data ){
261	for( index = 0; index < ip_routes_count( & ip_netif->routes ); ++ index ){	261	for( index = 0; index < ip_routes_count( & ip_netif->routes ); ++ index ){
262	route = ip_routes_get_index( & ip_netif->routes, index );	262	route = ip_routes_get_index( & ip_netif->routes, index );
263	if( route ){	263	if( route ){
264	printf( "\tRouting %d:\n", index );	264	printf( "\tRouting %d:\n", index );
265	inet_ntop( AF_INET, ( uint8_t * ) & route->address.s_addr, data, INET_ADDRSTRLEN );	265	inet_ntop( AF_INET, ( uint8_t * ) & route->address.s_addr, data, INET_ADDRSTRLEN );
266	printf( "\t\taddress\t= %s\n", data );	266	printf( "\t\taddress\t= %s\n", data );
267	inet_ntop( AF_INET, ( uint8_t * ) & route->netmask.s_addr, data, INET_ADDRSTRLEN );	267	inet_ntop( AF_INET, ( uint8_t * ) & route->netmask.s_addr, data, INET_ADDRSTRLEN );
268	printf( "\t\tnetmask\t= %s\n", data );	268	printf( "\t\tnetmask\t= %s\n", data );
269	inet_ntop( AF_INET, ( uint8_t * ) & route->gateway.s_addr, data, INET_ADDRSTRLEN );	269	inet_ntop( AF_INET, ( uint8_t * ) & route->gateway.s_addr, data, INET_ADDRSTRLEN );
270	printf( "\t\tgateway\t= %s\n", data );	270	printf( "\t\tgateway\t= %s\n", data );
271	}	271	}
272	}	272	}
273	inet_ntop( AF_INET, ( uint8_t * ) & ip_netif->broadcast.s_addr, data, INET_ADDRSTRLEN );	273	inet_ntop( AF_INET, ( uint8_t * ) & ip_netif->broadcast.s_addr, data, INET_ADDRSTRLEN );
274	printf( "\tbroadcast\t= %s\n", data );	274	printf( "\tbroadcast\t= %s\n", data );
275	inet_ntop( AF_INET, ( uint8_t * ) & ip_netif->dns1, data, INET_ADDRSTRLEN );	275	inet_ntop( AF_INET, ( uint8_t * ) & ip_netif->dns1, data, INET_ADDRSTRLEN );
276	printf( "\tdns1\t= %s\n", data );	276	printf( "\tdns1\t= %s\n", data );
277	inet_ntop( AF_INET, ( uint8_t * ) & ip_netif->dns2, data, INET_ADDRSTRLEN );	277	inet_ntop( AF_INET, ( uint8_t * ) & ip_netif->dns2, data, INET_ADDRSTRLEN );
278	printf( "\tdns2\t= %s\n", data );	278	printf( "\tdns2\t= %s\n", data );
279	free( data );	279	free( data );
280	}	280	}
281	fibril_rwlock_write_unlock( & ip_globals.netifs_lock );	281	fibril_rwlock_write_unlock( & ip_globals.netifs_lock );
282	return EOK;	282	return EOK;
283	}	283	}
284		284
285	int ip_netif_initialize( ip_netif_ref ip_netif ){	285	int ip_netif_initialize( ip_netif_ref ip_netif ){
286	ERROR_DECLARE;	286	ERROR_DECLARE;
287		287
288	measured_string_t names[] = {{ "IPV", 3 }, { "IP_CONFIG", 9 }, { "IP_ADDR", 7 }, { "NETMASK", 7 }, { "GATEWAY", 7 }, { "BROADCAST", 9 }, { "DNS1", 4 }, { "DNS2", 4 }, { "ARP", 3 }, { "IP_ROUTING", 10 }};	288	measured_string_t names[] = {{ "IPV", 3 }, { "IP_CONFIG", 9 }, { "IP_ADDR", 7 }, { "NETMASK", 7 }, { "GATEWAY", 7 }, { "BROADCAST", 9 }, { "DNS1", 4 }, { "DNS2", 4 }, { "ARP", 3 }, { "IP_ROUTING", 10 }};
289	measured_string_ref configuration;	289	measured_string_ref configuration;
290	size_t count = sizeof( names ) / sizeof( measured_string_t );	290	size_t count = sizeof( names ) / sizeof( measured_string_t );
291	char * data;	291	char * data;
292	measured_string_t address;	292	measured_string_t address;
293	int index;	293	int index;
294	ip_route_ref route;	294	ip_route_ref route;
295	in_addr_t gateway;	295	in_addr_t gateway;
296		296
297	ip_netif->arp = NULL;	297	ip_netif->arp = NULL;
298	route = NULL;	298	route = NULL;
299	ip_netif->ipv = NET_DEFAULT_IPV;	299	ip_netif->ipv = NET_DEFAULT_IPV;
300	ip_netif->dhcp = false;	300	ip_netif->dhcp = false;
301	ip_netif->routing = NET_DEFAULT_IP_ROUTING;	301	ip_netif->routing = NET_DEFAULT_IP_ROUTING;
302	configuration = & names[ 0 ];	302	configuration = & names[ 0 ];
303	// get configuration	303	// get configuration
304	ERROR_PROPAGATE( net_get_device_conf_req( ip_globals.net_phone, ip_netif->device_id, & configuration, count, & data ));	304	ERROR_PROPAGATE( net_get_device_conf_req( ip_globals.net_phone, ip_netif->device_id, & configuration, count, & data ));
305	if( configuration ){	305	if( configuration ){
306	if( configuration[ 0 ].value ){	306	if( configuration[ 0 ].value ){
307	ip_netif->ipv = strtol( configuration[ 0 ].value, NULL, 0 );	307	ip_netif->ipv = strtol( configuration[ 0 ].value, NULL, 0 );
308	}	308	}
309	ip_netif->dhcp = ! str_lcmp( configuration[ 1 ].value, "dhcp", configuration[ 1 ].length );	309	ip_netif->dhcp = ! str_lcmp( configuration[ 1 ].value, "dhcp", configuration[ 1 ].length );
310	if( ip_netif->dhcp ){	310	if( ip_netif->dhcp ){
311	// TODO dhcp	311	// TODO dhcp
312	net_free_settings( configuration, data );	312	net_free_settings( configuration, data );
313	return ENOTSUP;	313	return ENOTSUP;
314	}else if( ip_netif->ipv == IPV4 ){	314	}else if( ip_netif->ipv == IPV4 ){
315	route = ( ip_route_ref ) malloc( sizeof( ip_route_t ));	315	route = ( ip_route_ref ) malloc( sizeof( ip_route_t ));
316	if( ! route ){	316	if( ! route ){
317	net_free_settings( configuration, data );	317	net_free_settings( configuration, data );
318	return ENOMEM;	318	return ENOMEM;
319	}	319	}
320	route->address.s_addr = 0;	320	route->address.s_addr = 0;
321	route->netmask.s_addr = 0;	321	route->netmask.s_addr = 0;
322	route->gateway.s_addr = 0;	322	route->gateway.s_addr = 0;
323	route->netif = ip_netif;	323	route->netif = ip_netif;
324	index = ip_routes_add( & ip_netif->routes, route );	324	index = ip_routes_add( & ip_netif->routes, route );
325	if( index < 0 ){	325	if( index < 0 ){
326	net_free_settings( configuration, data );	326	net_free_settings( configuration, data );
327	free( route );	327	free( route );
328	return index;	328	return index;
329	}	329	}
330	if( ERROR_OCCURRED( inet_pton( AF_INET, configuration[ 2 ].value, ( uint8_t * ) & route->address.s_addr ))	330	if( ERROR_OCCURRED( inet_pton( AF_INET, configuration[ 2 ].value, ( uint8_t * ) & route->address.s_addr ))
331	\|\| ERROR_OCCURRED( inet_pton( AF_INET, configuration[ 3 ].value, ( uint8_t * ) & route->netmask.s_addr ))	331	\|\| ERROR_OCCURRED( inet_pton( AF_INET, configuration[ 3 ].value, ( uint8_t * ) & route->netmask.s_addr ))
332	\|\| ( inet_pton( AF_INET, configuration[ 4 ].value, ( uint8_t * ) & gateway.s_addr ) == EINVAL )	332	\|\| ( inet_pton( AF_INET, configuration[ 4 ].value, ( uint8_t * ) & gateway.s_addr ) == EINVAL )
333	\|\| ( inet_pton( AF_INET, configuration[ 5 ].value, ( uint8_t * ) & ip_netif->broadcast.s_addr ) == EINVAL )	333	\|\| ( inet_pton( AF_INET, configuration[ 5 ].value, ( uint8_t * ) & ip_netif->broadcast.s_addr ) == EINVAL )
334	\|\| ( inet_pton( AF_INET, configuration[ 6 ].value, ( uint8_t * ) & ip_netif->dns1 ) == EINVAL )	334	\|\| ( inet_pton( AF_INET, configuration[ 6 ].value, ( uint8_t * ) & ip_netif->dns1 ) == EINVAL )
335	\|\| ( inet_pton( AF_INET, configuration[ 7 ].value, ( uint8_t * ) & ip_netif->dns2 ) == EINVAL )){	335	\|\| ( inet_pton( AF_INET, configuration[ 7 ].value, ( uint8_t * ) & ip_netif->dns2 ) == EINVAL )){
336	net_free_settings( configuration, data );	336	net_free_settings( configuration, data );
337	return EINVAL;	337	return EINVAL;
338	}	338	}
339	}else{	339	}else{
340	// TODO ipv6 in separate module	340	// TODO ipv6 in separate module
341	net_free_settings( configuration, data );	341	net_free_settings( configuration, data );
342	return ENOTSUP;	342	return ENOTSUP;
343	}	343	}
344	if( configuration[ 8 ].value ){	344	if( configuration[ 8 ].value ){
345	ip_netif->arp = get_running_module( & ip_globals.modules, configuration[ 8 ].value );	345	ip_netif->arp = get_running_module( & ip_globals.modules, configuration[ 8 ].value );
346	if( ! ip_netif->arp ){	346	if( ! ip_netif->arp ){
347	printf( "Failed to start the arp %s\n", configuration[ 8 ].value );	347	printf( "Failed to start the arp %s\n", configuration[ 8 ].value );
348	net_free_settings( configuration, data );	348	net_free_settings( configuration, data );
349	return EINVAL;	349	return EINVAL;
350	}	350	}
351	}	351	}
352	if( configuration[ 9 ].value ){	352	if( configuration[ 9 ].value ){
353	ip_netif->routing = ( configuration[ 9 ].value[ 0 ] == 'y' );	353	ip_netif->routing = ( configuration[ 9 ].value[ 0 ] == 'y' );
354	}	354	}
355	net_free_settings( configuration, data );	355	net_free_settings( configuration, data );
356	}	356	}
357	// binds the netif service which also initializes the device	357	// binds the netif service which also initializes the device
358	ip_netif->phone = bind_service( ip_netif->service, ( ipcarg_t ) ip_netif->device_id, SERVICE_IP, 0, ip_globals.client_connection );	358	ip_netif->phone = bind_service( ip_netif->service, ( ipcarg_t ) ip_netif->device_id, SERVICE_IP, 0, ip_globals.client_connection );
359	if( ip_netif->phone < 0 ){	359	if( ip_netif->phone < 0 ){
360	printf( "Failed to contact the nil service %d\n", ip_netif->service );	360	printf( "Failed to contact the nil service %d\n", ip_netif->service );
361	return ip_netif->phone;	361	return ip_netif->phone;
362	}	362	}
363	// has to be after the device netif module initialization	363	// has to be after the device netif module initialization
364	if( ip_netif->arp ){	364	if( ip_netif->arp ){
365	if( route ){	365	if( route ){
366	address.value = ( char * ) & route->address.s_addr;	366	address.value = ( char * ) & route->address.s_addr;
367	address.length = CONVERT_SIZE( in_addr_t, char, 1 );	367	address.length = CONVERT_SIZE( in_addr_t, char, 1 );
368	ERROR_PROPAGATE( arp_device_req( ip_netif->arp->phone, ip_netif->device_id, SERVICE_IP, ip_netif->service, & address ));	368	ERROR_PROPAGATE( arp_device_req( ip_netif->arp->phone, ip_netif->device_id, SERVICE_IP, ip_netif->service, & address ));
369	}else{	369	}else{
370	ip_netif->arp = 0;	370	ip_netif->arp = 0;
371	}	371	}
372	}	372	}
373	// get packet dimensions	373	// get packet dimensions
374	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 ));	374	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 ));
375	if( ip_netif->content < IP_MIN_CONTENT ){	375	if( ip_netif->content < IP_MIN_CONTENT ){
376	printf( "Maximum transmission unit %d bytes is too small, at least %d bytes are needed\n", ip_netif->content, IP_MIN_CONTENT );	376	printf( "Maximum transmission unit %d bytes is too small, at least %d bytes are needed\n", ip_netif->content, IP_MIN_CONTENT );
377	ip_netif->content = IP_MIN_CONTENT;	377	ip_netif->content = IP_MIN_CONTENT;
378	}	378	}
379	index = ip_netifs_add( & ip_globals.netifs, ip_netif->device_id, ip_netif );	379	index = ip_netifs_add( & ip_globals.netifs, ip_netif->device_id, ip_netif );
380	if( index < 0 ) return index;	380	if( index < 0 ) return index;
381	if( gateway.s_addr ){	381	if( gateway.s_addr ){
382	// the default gateway	382	// the default gateway
383	ip_globals.gateway.address.s_addr = 0;	383	ip_globals.gateway.address.s_addr = 0;
384	ip_globals.gateway.netmask.s_addr = 0;	384	ip_globals.gateway.netmask.s_addr = 0;
385	ip_globals.gateway.gateway.s_addr = gateway.s_addr;	385	ip_globals.gateway.gateway.s_addr = gateway.s_addr;
386	ip_globals.gateway.netif = ip_netif;	386	ip_globals.gateway.netif = ip_netif;
387	}	387	}
388	return EOK;	388	return EOK;
389	}	389	}
390		390
391	int ip_mtu_changed_message( device_id_t device_id, size_t mtu ){	391	int ip_mtu_changed_message( device_id_t device_id, size_t mtu ){
392	ip_netif_ref netif;	392	ip_netif_ref netif;
393		393
394	fibril_rwlock_write_lock( & ip_globals.netifs_lock );	394	fibril_rwlock_write_lock( & ip_globals.netifs_lock );
395	netif = ip_netifs_find( & ip_globals.netifs, device_id );	395	netif = ip_netifs_find( & ip_globals.netifs, device_id );
396	if( ! netif ){	396	if( ! netif ){
397	fibril_rwlock_write_unlock( & ip_globals.netifs_lock );	397	fibril_rwlock_write_unlock( & ip_globals.netifs_lock );
398	return ENOENT;	398	return ENOENT;
399	}	399	}
400	netif->content = mtu;	400	netif->content = mtu;
401	printf( "ip - device %d changed mtu to %d\n\n", device_id, mtu );	401	printf( "ip - device %d changed mtu to %d\n\n", device_id, mtu );
402	fibril_rwlock_write_unlock( & ip_globals.netifs_lock );	402	fibril_rwlock_write_unlock( & ip_globals.netifs_lock );
403	return EOK;	403	return EOK;
404	}	404	}
405		405
406	int ip_device_state_message( device_id_t device_id, device_state_t state ){	406	int ip_device_state_message( device_id_t device_id, device_state_t state ){
407	// ERROR_DECLARE;	-
408		-
409	/* measured_string_t address;	-
410	measured_string_ref translation;	-
411	char * data;	-
412	*/	-
413	/* packet_t packet;	-
414	in_addr_t destination;	-
415	*/	-
416	ip_netif_ref netif;	407	ip_netif_ref netif;
417		408
418	fibril_rwlock_write_lock( & ip_globals.netifs_lock );	409	fibril_rwlock_write_lock( & ip_globals.netifs_lock );
-		410	// find the device
419	netif = ip_netifs_find( & ip_globals.netifs, device_id );	411	netif = ip_netifs_find( & ip_globals.netifs, device_id );
420	if( ! netif ){	412	if( ! netif ){
421	fibril_rwlock_write_unlock( & ip_globals.netifs_lock );	413	fibril_rwlock_write_unlock( & ip_globals.netifs_lock );
422	return ENOENT;	414	return ENOENT;
423	}	415	}
424	netif->state = state;	416	netif->state = state;
425	// TODO state	-
426	printf( "ip - device %d changed state to %d\n\n", device_id, state );	417	printf( "ip - device %d changed state to %d\n\n", device_id, state );
427	fibril_rwlock_write_unlock( & ip_globals.netifs_lock );	418	fibril_rwlock_write_unlock( & ip_globals.netifs_lock );
428	// if( netif->arp ){	-
429	/* address.value = ( char * ) & ip_globals.gateway.gateway.s_addr;	-
430	address.length = CONVERT_SIZE( ip_globals.gateway.gateway.s_addr, char, 1 );	-
431	if( ERROR_OCCURRED( arp_translate_req( netif->arp->phone, netif->device_id, SERVICE_IP, & address, & translation, & data ))){	-
432	ERROR_PROPAGATE( arp_translate_req( netif->arp->phone, netif->device_id, SERVICE_IP, & address, & translation, & data ));	-
433	}	-
434	printf( "\tgateway translated to\t= %X:%X:%X:%X:%X:%X\n", data[ 0 ], data[ 1 ], data[ 2 ], data[ 3 ], data[ 4 ], data[ 5 ] );	-
435	free( translation );	-
436	free( data );	-
437	address.value = ( char * ) & ip_globals.gateway.gateway.s_addr;	-
438	address.length = CONVERT_SIZE( ip_globals.gateway.gateway.s_addr, char, 1 );	-
439	if( ERROR_OCCURRED( arp_translate_req( netif->arp->phone, netif->device_id, SERVICE_IP, & address, & translation, & data ))){	-
440	sleep( 2 );	-
441	ERROR_PROPAGATE( arp_translate_req( netif->arp->phone, netif->device_id, SERVICE_IP, & address, & translation, & data ));	-
442	}	-
443	printf( "\tgateway translated to\t= %X:%X:%X:%X:%X:%X\n", data[ 0 ], data[ 1 ], data[ 2 ], data[ 3 ], data[ 4 ], data[ 5 ] );	-
444	free( translation );	-
445	free( data );	-
446	// printf( "IP - testing to send packet:\n" );	-
447	ERROR_PROPAGATE( inet_pton( AF_INET, "90.182.101.18", ( uint8_t * ) & destination.s_addr ));	-
448	packet = packet_get_4( ip_globals.net_phone, 30, netif->addr_len, netif->prefix + sizeof( ip_header_t ), netif->suffix );	-
449	if( ! packet ) return ENOMEM;	-
450	pq_release( ip_globals.net_phone, packet_get_id( packet ));	-
451	packet = packet_get_4( ip_globals.net_phone, 30, netif->addr_len, netif->prefix + sizeof( ip_header_t ), netif->suffix );	-
452	if( ! packet ) return ENOMEM;	-
453	pq_release( ip_globals.net_phone, packet_get_id( packet ));	-
454	packet = packet_get_4( ip_globals.net_phone, 30, netif->addr_len, netif->prefix + sizeof( ip_header_t ), netif->suffix );	-
455	if( ! packet ) return ENOMEM;	-
456	pq_release( ip_globals.net_phone, packet_get_id( packet ));	-
457	packet = packet_get_4( ip_globals.net_phone, 1500, netif->addr_len, netif->prefix + sizeof( ip_header_t ), netif->suffix );	-
458	if( ! packet ) return ENOMEM;	-
459	// try this long version	-
460	// if( ERROR_OCCURRED( packet_copy_data( packet, "Hi, this is IP, wery long version 1, wery long version 2, wery long version 3, wery long version 4, wery long version 5, wery long version 6, wery long version 7, wery long version 8, wery long version 9, wery long version 10, wery long version 11, wery long version 12, wery long version 13, wery long version 14, wery long version 15, wery long version 16, wery long version 17, wery long version 18, wery long version 19, wery long version 20, wery long version 21, wery long version 22, wery long version 23, wery long version 24, wery long version 25, wery long version 26, wery long version 27, wery long version 28, wery long version 29, wery long version 30Hi, this is IP, wery long version 1, wery long version 2, wery long version 3, wery long version 4, wery long version 5, wery long version 6, wery long version 7, wery long version 8, wery long version 9, wery long version 10, wery long version 11, wery long version 12, wery long version 13, wery long version 14, wery long version 15, wery long version 16, wery long version 17, wery long version 18, wery long version 19, wery long version 20, wery long version 21, wery long version 22, wery long version 23, wery long version 24, wery long version 25, wery long version 26, wery long version 27, wery long version 28, wery long version 29, wery long version 30", 1330 ))	-
461	if( ERROR_OCCURRED( packet_copy_data( packet, "Hi, this is IP", 14 ))	-
462	\|\| ERROR_OCCURRED( packet_set_addr( packet, NULL, ( uint8_t * ) & destination.s_addr, 4 ))	-
463	\|\| ERROR_OCCURRED( ip_client_prepare_packet( packet, 0, 0, 0, 0, 0 ))){	-
464	pq_release( ip_globals.net_phone, packet_get_id( packet ));	-
465	}	-
466	ERROR_CODE = ip_send_msg( 0, 0, packet, SERVICE_IP );	-
467	printf( "send returned %d\n", ERROR_CODE );	-
468	}	-
469	*/ return EOK;	419	return EOK;
470	}	420	}
471		421
472	int ip_connect_module( services_t service ){	422	int ip_connect_module( services_t service ){
473	return EOK;	423	return EOK;
474	}	424	}
475		425
476	int ip_bind_service( services_t service, int protocol, services_t me, async_client_conn_t receiver, tl_received_msg_t received_msg ){	426	int ip_bind_service( services_t service, int protocol, services_t me, async_client_conn_t receiver, tl_received_msg_t received_msg ){
477	return ip_register( protocol, me, 0, received_msg );	427	return ip_register( protocol, me, 0, received_msg );
478	}	428	}
479		429
480	int ip_register( int protocol, services_t service, int phone, tl_received_msg_t received_msg ){	430	int ip_register( int protocol, services_t service, int phone, tl_received_msg_t received_msg ){
481	ip_proto_ref proto;	431	ip_proto_ref proto;
482	int index;	432	int index;
483		433
484	if( !( protocol && service && (( phone > 0 ) \|\| ( received_msg )))) return EINVAL;	434	if( !( protocol && service && (( phone > 0 ) \|\| ( received_msg )))) return EINVAL;
485	proto = ( ip_proto_ref ) malloc( sizeof( ip_protos_t ));	435	proto = ( ip_proto_ref ) malloc( sizeof( ip_protos_t ));
486	if( ! proto ) return ENOMEM;	436	if( ! proto ) return ENOMEM;
487	proto->protocol = protocol;	437	proto->protocol = protocol;
488	proto->service = service;	438	proto->service = service;
489	proto->phone = phone;	439	proto->phone = phone;
490	proto->received_msg = received_msg;	440	proto->received_msg = received_msg;
491	fibril_rwlock_write_lock( & ip_globals.protos_lock );	441	fibril_rwlock_write_lock( & ip_globals.protos_lock );
492	index = ip_protos_add( & ip_globals.protos, proto->protocol, proto );	442	index = ip_protos_add( & ip_globals.protos, proto->protocol, proto );
493	if( index < 0 ){	443	if( index < 0 ){
494	fibril_rwlock_write_unlock( & ip_globals.protos_lock );	444	fibril_rwlock_write_unlock( & ip_globals.protos_lock );
495	free( proto );	445	free( proto );
496	return index;	446	return index;
497	}	447	}
498	printf( "New protocol registered:\n\tprotocol\t= %d\n\tphone\t= %d\n", proto->protocol, proto->phone );	448	printf( "New protocol registered:\n\tprotocol\t= %d\n\tphone\t= %d\n", proto->protocol, proto->phone );
499	fibril_rwlock_write_unlock( & ip_globals.protos_lock );	449	fibril_rwlock_write_unlock( & ip_globals.protos_lock );

Subversion Repositories HelenOS

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