Subversion Repositories HelenOS

/*

 * 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 );

        if( netif && ( ! route ) && ( ip_globals.gateway.netif == netif )){

            route = & ip_globals.gateway;

        }

    }else{

        route = ip_find_route( * dest );

        netif = route ? route->netif : NULL;

    }

    if( !( netif && route )){

        fibril_rwlock_read_unlock( & ip_globals.netifs_lock );

        phone = ip_prepare_icmp_and_get_phone( error, packet, NULL );

        if( phone >= 0 ){

            // unreachable ICMP if no routing

            icmp_destination_unreachable_msg( phone, ICMP_NET_UNREACH, 0, packet );

        }

        return ENOENT;

    }

    if( error ){

        // do not send for broadcast, anycast packets or network broadcast

        if(( ! dest->s_addr )

        || ( !( ~ dest->s_addr ))

        || ( !( ~(( dest->s_addr & ( ~ route->netmask.s_addr )) | route->netmask.s_addr )))

        || ( !( dest->s_addr & ( ~ route->netmask.s_addr )))){

            return ip_release_and_return( packet, EINVAL );

        }

    }

    if( route->address.s_addr == dest->s_addr ){

        // find the loopback device to deliver

        dest->s_addr = IPV4_LOCALHOST_ADDRESS;

        route = ip_find_route( * dest );

        netif = route ? route->netif : NULL;

        if( !( netif && route )){

            fibril_rwlock_read_unlock( & ip_globals.netifs_lock );

            phone = ip_prepare_icmp_and_get_phone( error, packet, NULL );

            if( phone >= 0 ){

                // unreachable ICMP if no routing

                icmp_destination_unreachable_msg( phone, ICMP_HOST_UNREACH, 0, packet );

            }

            return ENOENT;

        }

    }

    src = ip_netif_address( netif );

    if( ! src ){

        fibril_rwlock_read_unlock( & ip_globals.netifs_lock );

        return ip_release_and_return( packet, ENOENT );

    }

    ERROR_CODE = ip_send_route( packet, netif, route, src, * dest, error );

    fibril_rwlock_read_unlock( & ip_globals.netifs_lock );

    return ERROR_CODE;

}

in_addr_t * ip_netif_address( ip_netif_ref netif ){

    ip_route_ref    route;

    route = ip_routes_get_index( & netif->routes, 0 );

    return route ? & route->address : NULL;

}

int ip_send_route( packet_t packet, ip_netif_ref netif, ip_route_ref route, in_addr_t * src, in_addr_t dest, services_t error ){

    ERROR_DECLARE;

    measured_string_t   destination;

    measured_string_ref translation;

    char *              data;

    int                 phone;

    // get destination hardware address

    if( netif->arp && ( route->address.s_addr != dest.s_addr )){

        destination.value = route->gateway.s_addr ? ( char * ) & route->gateway.s_addr : ( char * ) & dest.s_addr;

        destination.length = CONVERT_SIZE( dest.s_addr, char, 1 );

        if( ERROR_OCCURRED( arp_translate_req( netif->arp->phone, netif->device_id, SERVICE_IP, & destination, & translation, & data ))){

//          sleep( 1 );

//          ERROR_PROPAGATE( arp_translate_req( netif->arp->phone, netif->device_id, SERVICE_IP, & destination, & translation, & data ));

            pq_release( ip_globals.net_phone, packet_get_id( packet ));

            return ERROR_CODE;

        }

        if( !( translation && translation->value )){

            if( translation ){

                free( translation );

                free( data );

            }

            phone = ip_prepare_icmp_and_get_phone( error, packet, NULL );

            if( phone >= 0 ){

                // unreachable ICMP if no routing

                icmp_destination_unreachable_msg( phone, ICMP_HOST_UNREACH, 0, packet );

            }

            return EINVAL;

        }

    }else translation = NULL;

    if( ERROR_OCCURRED( ip_prepare_packet( src, dest, packet, translation ))){

        pq_release( ip_globals.net_phone, packet_get_id( packet ));

    }else{

        packet = ip_split_packet( packet, netif->prefix, netif->content, netif->suffix, netif->addr_len, error );

        if( packet ){

            nil_send_msg( netif->phone, netif->device_id, packet, SERVICE_IP );

        }

    }

    if( translation ){

        free( translation );

        free( data );

    }

    return ERROR_CODE;

}

int ip_prepare_packet( in_addr_t * source, in_addr_t dest, packet_t packet, measured_string_ref destination ){

    ERROR_DECLARE;

    size_t              length;

    ip_header_ref       header;

    ip_header_ref       last_header;

    ip_header_ref       middle_header;

    packet_t            next;

    length = packet_get_data_length( packet );

    if(( length < sizeof( ip_header_t )) || ( length > IP_MAX_CONTENT )) return EINVAL;

    header = ( ip_header_ref ) packet_get_data( packet );

    if( destination ){

        ERROR_PROPAGATE( packet_set_addr( packet, NULL, ( uint8_t * ) destination->value, CONVERT_SIZE( char, uint8_t, destination->length )));

    }else{

        ERROR_PROPAGATE( packet_set_addr( packet, NULL, NULL, 0 ));

    }

    header->version = IPV4;

    header->fragment_offset_high = 0;

    header->fragment_offset_low = 0;

    header->header_checksum = 0;

    if( source ) header->source_address = source->s_addr;

    header->destination_address = dest.s_addr;

    fibril_rwlock_write_lock( & ip_globals.lock );

    ++ ip_globals.packet_counter;

    header->identification = htons( ip_globals.packet_counter );

    fibril_rwlock_write_unlock( & ip_globals.lock );

//  length = packet_get_data_length( packet );

    if( pq_next( packet )){

        last_header = ( ip_header_ref ) malloc( IP_HEADER_LENGTH( header ));

        if( ! last_header ) return ENOMEM;

        ip_create_last_header( last_header, header );

        next = pq_next( packet );

        while( pq_next( next )){

            middle_header = ( ip_header_ref ) packet_prefix( next, IP_HEADER_LENGTH( last_header ));

            if( ! middle_header ) return ENOMEM;

            memcpy( middle_header, last_header, IP_HEADER_LENGTH( last_header ));

            header->flags |= IPFLAG_MORE_FRAGMENTS;

            middle_header->total_length = htons( packet_get_data_length( next ));

            middle_header->fragment_offset_high = IP_COMPUTE_FRAGMENT_OFFSET_HIGH( length );

            middle_header->fragment_offset_low = IP_COMPUTE_FRAGMENT_OFFSET_LOW( length );

            middle_header->header_checksum = IP_HEADER_CHECKSUM( middle_header );

            if( destination ){

                ERROR_PROPAGATE( packet_set_addr( next, NULL, ( uint8_t * ) destination->value, CONVERT_SIZE( char, uint8_t, destination->length )));

            }

            length += packet_get_data_length( next );

            next = pq_next( next );

        }

        middle_header = ( ip_header_ref ) packet_prefix( next, IP_HEADER_LENGTH( last_header ));

        if( ! middle_header ) return ENOMEM;

        memcpy( middle_header, last_header, IP_HEADER_LENGTH( last_header ));

        middle_header->total_length = htons( packet_get_data_length( next ));

        middle_header->fragment_offset_high = IP_COMPUTE_FRAGMENT_OFFSET_HIGH( length );

        middle_header->fragment_offset_low = IP_COMPUTE_FRAGMENT_OFFSET_LOW( length );

        middle_header->header_checksum = IP_HEADER_CHECKSUM( middle_header );

        if( destination ){

            ERROR_PROPAGATE( packet_set_addr( next, NULL, ( uint8_t * ) destination->value, CONVERT_SIZE( char, uint8_t, destination->length )));

        }

        length += packet_get_data_length( next );

        free( last_header );

        header->flags |= IPFLAG_MORE_FRAGMENTS;

    }

    header->total_length = htons( length );

    // unnecessary for all protocols

    header->header_checksum = IP_HEADER_CHECKSUM( header );

    return EOK;

}

int ip_message( ipc_callid_t callid, ipc_call_t * call, ipc_call_t * answer, int * answer_count ){

    ERROR_DECLARE;

    packet_t                packet;

    struct sockaddr *       addr;

    size_t                  addrlen;

    ip_pseudo_header_ref    header;

    size_t                  headerlen;

    * answer_count = 0;

    switch( IPC_GET_METHOD( * call )){

        case IPC_M_PHONE_HUNGUP:

            return EOK;

        case NET_IL_DEVICE:

            return ip_device_req( 0, IPC_GET_DEVICE( call ), IPC_GET_SERVICE( call ));

        case IPC_M_CONNECT_TO_ME:

            return ip_register( IL_GET_PROTO( call ), IL_GET_SERVICE( call ), IPC_GET_PHONE( call ), NULL );

        case NET_IL_SEND:

            ERROR_PROPAGATE( packet_translate( ip_globals.net_phone, & packet, IPC_GET_PACKET( call )));

            return ip_send_msg( 0, IPC_GET_DEVICE( call ), packet, 0, IPC_GET_ERROR( call ));

        case NET_IL_DEVICE_STATE:

            return ip_device_state_message( IPC_GET_DEVICE( call ), IPC_GET_STATE( call ));

        case NET_IL_RECEIVED:

            ERROR_PROPAGATE( packet_translate( ip_globals.net_phone, & packet, IPC_GET_PACKET( call )));

            return ip_receive_message( IPC_GET_DEVICE( call ), packet );

        case NET_IP_RECEIVED_ERROR:

            ERROR_PROPAGATE( packet_translate( ip_globals.net_phone, & packet, IPC_GET_PACKET( call )));

            return ip_received_error_msg( 0, IPC_GET_DEVICE( call ), packet, IPC_GET_TARGET( call ), IPC_GET_ERROR( call ));

        case NET_IP_ADD_ROUTE:

            return ip_add_route_req( 0, IPC_GET_DEVICE( call ), IP_GET_ADDRESS( call ), IP_GET_NETMASK( call ), IP_GET_GATEWAY( call ));

        case NET_IP_SET_GATEWAY:

            return ip_set_gateway_req( 0, IPC_GET_DEVICE( call ), IP_GET_GATEWAY( call ));