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
 */
 
#include <async.h>
#include <errno.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/net_interface.h"
#include "../../include/sockaddr.h"
#include "../../include/socket.h"
#include "../../include/byteorder.h"
#include "../../include/crc.h"
#include "../../include/device.h"
#include "../../include/arp_interface.h"
#include "../../include/nil_interface.h"
#include "../../include/il_interface.h"
#include "../../include/ip_client.h"
#include "../../include/ip_interface.h"
#include "../../include/tl_interface.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"
 
#define DEFAULT_IPV     4
#define IP_MIN_CONTENT  576
 
#define ARP_NAME                "arp"
#define ARP_FILENAME            "/srv/arp"
 
#define IP_ADDR                         sizeof( in_addr_t )
#define IP_PREFIX                       sizeof( ip_header_t )
#define IP_SUFFIX                       0
#define IP_MAX_CONTENT                  65535
#define IP_HEADER_LENGTH( header )      (( header )->ihl * 4 )
#define IP_TOTAL_LENGTH( header )       ntohs(( header )->total_length )
#define IP_HEADER_DATA_LENGTH( header ) ( IP_TOTAL_LENGTH( header ) - IP_HEADER_LENGTH( header ))
#define IP_HEADER_CHECKSUM( header )    ( htons( ip_checksum(( uint8_t * )( header ), IP_HEADER_LENGTH( header ))))
 
//zero is returned as 0xFFFF (not flipped)
#define IP_HEADER_CHECKSUM_ZERO         0xFFFF
 
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 )
 
int ip_device_state_msg( int il_phone, 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 );
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 );
int ip_prepare_packet( in_addr_t * source, packet_t packet, measured_string_ref destination );
 
packet_t    ip_split_packet( packet_t packet, size_t prefix, size_t content, size_t suffix, size_t addr_len );
int ip_fragment_packet( packet_t packet, size_t length, size_t prefix, size_t suffix, size_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, void * src, void * dest, size_t address_length );
ip_header_ref   ip_create_middle_header( packet_t packet, ip_header_ref last );
ip_header_ref   ip_create_last_header( packet_t packet, ip_header_ref first );
 
in_addr_t * ip_netif_addr( 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 );
 
int ip_received_msg( 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 );
 
/** Computes the ip header checksum.
 *  To compute the checksum of a new packet, the checksum header field must be zero.
 *  To check the checksum of a received packet, the checksum may be left set.
 *  The zero (0) value will returned in this case if valid.
 *  @param data The header data. Input parameter.
 *  @param length The header length in bytes. Input parameter.
 *  @returns The internet protocol header checksum.
 *  @returns IP_HEADER_CHECKSUM_ZERO if the computed checksum is zero.
 */
uint16_t ip_checksum( uint8_t * data, int length );
 
uint16_t ip_checksum( uint8_t * data, int length ){
    uint16_t    checksum;
 
    checksum = compact_checksum(compute_checksum( 0, data, length ));
 
    // flip, zero is returned as 0xFFFF (not flipped)
    return ( ~ checksum ) ? ~ checksum : IP_HEADER_CHECKSUM_ZERO;
}
 
/** Initializes the module.
 */
int ip_initialize( async_client_conn_t client_connection ){
    ERROR_DECLARE;
 
    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 ));
    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;
    if( ERROR_OCCURRED( ip_netif_initialize( ip_netif ))){
        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 );
    }
    return EOK;
}
 
int ip_netif_initialize( ip_netif_ref ip_netif ){
    ERROR_DECLARE;
 
    measured_string_t   names[ 9 ] = {{ "IPV", 3 }, { "IP_CONFIG", 9 }, { "IP_ADDR", 7 }, { "NETMASK", 7 }, { "GATEWAY", 7 }, { "BROADCAST", 9 }, { "DNS1", 4 }, { "DNS2", 4 }, { "ARP", 3 }};
    measured_string_ref configuration;
    size_t              count = sizeof( names ) / sizeof( measured_string_t );
    char *              data;
    int                 index;
    ip_route_ref        route;
    in_addr_t           gateway;
 
    ip_netif->arp = 0;
    route = NULL;
    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 );
        }else{
            ip_netif->ipv = DEFAULT_IPV;
        }
        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 == 4 ){
            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;
            }
        }else{
            ip_netif->arp = NULL;
        }
        net_free_settings( configuration, data );
    }
    ip_netif->phone = bind_service( ip_netif->service, 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;
    }
    // MUST BE AFTER the bind_service up there!
    if( ip_netif->arp ){
        if( route ){
            configuration[ 0 ].value = ( char * ) & route->address.s_addr;
            configuration[ 0 ].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, & configuration[ 0 ] ));
        }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_device_state_msg( int il_phone, device_id_t device_id, device_state_t state ){
//  ERROR_DECLARE;
 
/*  measured_string_t   address;
    measured_string_ref translation;
    char *              data;
*/
/*  packet_t        packet;
    in_addr_t       destination;
*/
    ip_netif_ref    netif;
 
    netif = ip_netifs_find( & ip_globals.netifs, device_id );
    if( ! netif ) return ENOENT;
    netif->state = state;
    // TODO state
    printf( "ip - device %d changed state to %d\n\n", device_id, state );
//  if( netif->arp ){
/*      address.value = ( char * ) & ip_globals.gateway.gateway.s_addr;
        address.length = CONVERT_SIZE( ip_globals.gateway.gateway.s_addr, char, 1 );
        if( ERROR_OCCURRED( arp_translate_req( netif->arp->phone, netif->device_id, SERVICE_IP, & address, & translation, & data ))){
            ERROR_PROPAGATE( arp_translate_req( netif->arp->phone, netif->device_id, SERVICE_IP, & address, & translation, & data ));
        }
        printf( "\tgateway translated to\t= %X:%X:%X:%X:%X:%X\n", data[ 0 ], data[ 1 ], data[ 2 ], data[ 3 ], data[ 4 ], data[ 5 ] );
        free( translation );
        free( data );
        address.value = ( char * ) & ip_globals.gateway.gateway.s_addr;
        address.length = CONVERT_SIZE( ip_globals.gateway.gateway.s_addr, char, 1 );
        if( ERROR_OCCURRED( arp_translate_req( netif->arp->phone, netif->device_id, SERVICE_IP, & address, & translation, & data ))){
            sleep( 2 );
            ERROR_PROPAGATE( arp_translate_req( netif->arp->phone, netif->device_id, SERVICE_IP, & address, & translation, & data ));
        }
        printf( "\tgateway translated to\t= %X:%X:%X:%X:%X:%X\n", data[ 0 ], data[ 1 ], data[ 2 ], data[ 3 ], data[ 4 ], data[ 5 ] );
        free( translation );
        free( data );
*//*        printf( "IP - testing to send packet:\n" );
        ERROR_PROPAGATE( inet_pton( AF_INET, "90.182.101.18", ( uint8_t * ) & destination.s_addr ));
        packet = packet_get_4( ip_globals.net_phone, 30, netif->addr_len, netif->prefix + sizeof( ip_header_t ), netif->suffix );
        if( ! packet ) return ENOMEM;
        pq_release( ip_globals.net_phone, packet_get_id( packet ));
        packet = packet_get_4( ip_globals.net_phone, 30, netif->addr_len, netif->prefix + sizeof( ip_header_t ), netif->suffix );
        if( ! packet ) return ENOMEM;
        pq_release( ip_globals.net_phone, packet_get_id( packet ));
        packet = packet_get_4( ip_globals.net_phone, 30, netif->addr_len, netif->prefix + sizeof( ip_header_t ), netif->suffix );
        if( ! packet ) return ENOMEM;
        pq_release( ip_globals.net_phone, packet_get_id( packet ));
        packet = packet_get_4( ip_globals.net_phone, 1500, netif->addr_len, netif->prefix + sizeof( ip_header_t ), netif->suffix );
        if( ! packet ) return ENOMEM;
        // try this long version
//      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 ))
        if( ERROR_OCCURRED( packet_copy_data( packet, "Hi, this is IP", 14 ))
        || ERROR_OCCURRED( packet_set_addr( packet, NULL, ( uint8_t * ) & destination.s_addr, 4 ))
        || ERROR_OCCURRED( ip_client_prepare_packet( packet, 0, 0, 0, 0, 0 ))){
            pq_release( ip_globals.net_phone, packet_get_id( packet ));
        }
        ERROR_CODE = ip_send_msg( 0, 0, packet, SERVICE_IP );
        printf( "send returned %d\n", ERROR_CODE );
    }
*/  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 tl_received_msg ){
    return ip_register( protocol, me, 0, tl_received_msg );
}
 
int ip_register( int protocol, services_t service, int phone, tl_received_msg_t tl_received_msg ){
    ip_proto_ref    proto;
    int             index;
 
    if( !( protocol && service && (( phone > 0 ) || ( tl_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->tl_received_msg = tl_received_msg;
    index = ip_protos_add( & ip_globals.protos, proto->protocol, proto );
    if( index < 0 ){
        free( proto );
        return index;
    }
    printf( "New protocol registered:\n\tprotocol\t= %d\n\tphone\t= %d\n", proto->protocol, proto->phone );
    return EOK;
}
 
int ip_send_msg( int il_phone, device_id_t device_id, packet_t packet, services_t sender ){
    ERROR_DECLARE;
 
    int                 length;
    ip_netif_ref        netif;
    ip_route_ref        route;
    in_addr_t           dest;
    in_addr_t *         src;
 
    // addresses in the host byte order
    // should be the next hop address or the target destination address
    length = packet_get_addr( packet, NULL, ( void * )( & dest.s_addr ));
    if( length < 0 ){
        pq_release( ip_globals.net_phone, packet_get_id( packet ));
        return length;
    }
    // TODO IPv6
    if( length != IP_ADDR ){
        pq_release( ip_globals.net_phone, packet_get_id( packet ));
        return EINVAL;
    }
//  rwlock_read_lock( & ip_globals.devices_lock );
    // device specified?
//  dest.s_addr = ntohl( dest.s_addr );
    if( device_id ){
        netif = ip_netifs_find( & ip_globals.netifs, device_id );
        route = ip_netif_find_route( netif, dest );
    }else{
        // TODO IPv6
        route = ip_find_route( dest );
        netif = route ? route->netif : NULL;
    }
    if( !( netif && route )){
//      rwlock_read_unlock( & ip_globals.devices_lock );
        pq_release( ip_globals.net_phone, packet_get_id( packet ));
        return ENOENT;
    }
    // to me?
    if( route->address.s_addr == dest.s_addr ){
        // TODO loopback deliver
    }
 
    src = ip_netif_addr( netif );
    if( ! src ){
        pq_release( ip_globals.net_phone, packet_get_id( packet ));
        return ENOENT;
    }
    if( ERROR_OCCURRED( ip_send_route( packet, netif, route, src, dest ))){
        pq_release( ip_globals.net_phone, packet_get_id( packet ));
    }
    return ERROR_CODE;
}
 
in_addr_t * ip_netif_addr( 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 ){
    ERROR_DECLARE;
 
    packet_t            next;
    packet_t            tmp;
    measured_string_t   destination;
    measured_string_ref translation;
    char *              data;
 
    if( route->gateway.s_addr ){
        dest.s_addr = route->gateway.s_addr;
    }
    // get destination hardware address
    if( netif->arp ){
        destination.value = ( 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 ))){
            usleep( 200000 );
            ERROR_PROPAGATE( arp_translate_req( netif->arp->phone, netif->device_id, SERVICE_IP, & destination, & translation, & data ));
        }
        // TODO unreachable
        if( ! translation ) return EINVAL;
        if( ! translation->value ){
            // TODO unreachable
            free( translation );
            free( data );
            return EINVAL;
        }
    }else translation = NULL;
    // process packet queue
    next = packet;
    do{
        if( ERROR_OCCURRED( ip_prepare_packet( src, next, translation ))){
            // release invalid packet
            tmp = pq_detach( next );
            if( next == packet ) packet = tmp;
            pq_release( ip_globals.net_phone, packet_get_id( next ));
            next = tmp;
        }else{
            next = pq_next( next );
        }
    }while( next );
    if( translation ){
        free( translation );
        free( data );
    }
    // send packet queue
    if( packet ){
        packet = ip_split_packet( packet, netif->prefix, netif->content, netif->suffix, netif->addr_len );
        if( packet ){
            nil_send_msg( netif->phone, netif->device_id, packet, SERVICE_IP );
        }
    }
//  rwlock_read_unlock( & ip_globals.netifs_lock );
    return EOK;
}
 
int ip_prepare_packet( in_addr_t * source, packet_t packet, measured_string_ref destination ){
    ERROR_DECLARE;
 
    int                 length;
    ip_header_ref       header;
 
    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 )));
    }
    header->version = 4;
    header->total_length = htons( length );
    header->fragment_offset = 0;
    if( source ) header->source_address = source->s_addr;//htonl( source.s_addr );
    ++ ip_globals.packet_counter;
    header->identification = htons( ip_globals.packet_counter );
    header->header_checksum = 0;
    // 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;
 
    * 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 );
        case NET_IL_DEVICE_STATE:
        case NET_NIL_DEVICE_STATE:
            return ip_device_state_msg( 0, IPC_GET_DEVICE( call ), IPC_GET_STATE( call ));
        case NET_IL_RECEIVED:
        case NET_NIL_RECEIVED:
            ERROR_PROPAGATE( packet_translate( ip_globals.net_phone, & packet, IPC_GET_PACKET( call )));
            return ip_received_msg( IPC_GET_DEVICE( call ), packet );
        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_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;
    }
    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;
 
    if( !( addr_len && prefix && content && suffix )) return EBADMEM;
//  rwlock_read_lock( & ip_globals.netifs_lock );
    netif = ip_netifs_find( & ip_globals.netifs, device_id );
    if( ! netif ){
//      rwlock_read_unlock( & ip_globals.netifs_lock );
        return ENOENT;
    }
    * content = IP_MAX_CONTENT - IP_PREFIX;
    * addr_len = ( netif->addr_len > IP_ADDR ) ? netif->addr_len : IP_ADDR;
    * prefix = netif->prefix + IP_PREFIX;
    * suffix = netif->suffix + IP_SUFFIX;
//  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;
 
    netif = ip_netifs_find( & ip_globals.netifs, device_id );
    if( ! netif ) return ENOENT;
    route = ( ip_route_ref ) malloc( sizeof( ip_route_t ));
    if( ! route ) 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 );
    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;
 
    netif = ip_netifs_find( & ip_globals.netifs, device_id );
    if( ! netif ) 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;
    return EOK;
}
 
packet_t ip_split_packet( packet_t packet, size_t prefix, size_t content, size_t suffix, size_t addr_len ){
    size_t          length;
    packet_t        next;
    packet_t        new_packet;
 
    next = packet;
    // check all packets
    while( next ){
        length = packet_get_data_length( next );
        // too long?
        if( length > content ){
            if( ip_fragment_packet( next, content, prefix, suffix, addr_len ) != EOK ){
                new_packet = pq_detach( next );
                if( next == packet ){
                    packet = new_packet;
                }
                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, size_t addr_len ){
    ERROR_DECLARE;
 
    packet_t        new_packet;
    ip_header_ref   header;
    ip_header_ref   middle_header;
    ip_header_ref   last_header;
    uint8_t *       src;
    uint8_t *       dest;
    int             address_length;
 
    address_length = packet_get_addr( packet, & src, & dest );
    if( address_length <= 0 ) return EINVAL;
    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 ){
        // TODO fragmentation necessary ICMP
        return EPERM;
    }
    // create the last fragment
    new_packet = packet_get_4( ip_globals.net_phone, prefix, length, suffix, (( address_length > addr_len ) ? address_length : addr_len ));
    if( ! new_packet ) return ENOMEM;
    last_header = ip_create_last_header( new_packet, header );
    if( ! last_header ){
        pq_release( ip_globals.net_phone, packet_get_id( new_packet ));
        return ENOMEM;
    }
    // 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_TOTAL_LENGTH( header ) - length ) % ( length - IP_HEADER_LENGTH( last_header ))), src, dest, address_length ))){
        pq_release( ip_globals.net_phone, packet_get_id( new_packet ));
        return 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, (( address_length >= addr_len ) ? address_length : addr_len ));
        if( ! new_packet ) return ENOMEM;
        middle_header = ip_create_middle_header( new_packet, last_header );
        if( ! middle_header ){
            pq_release( ip_globals.net_phone, packet_get_id( new_packet ));
            return ENOMEM;
        }
        if( ERROR_OCCURRED( ip_fragment_packet_data( packet, new_packet, header, middle_header, length - IP_HEADER_LENGTH( middle_header ), src, dest, address_length ))){
            pq_release( ip_globals.net_phone, packet_get_id( new_packet ));
            return ERROR_CODE;
        }
    }
    // finish the first fragment
    header->header_checksum = IP_HEADER_CHECKSUM( header );
    printf( "ok\n" );
    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, void * src, void * dest, size_t address_length ){
    ERROR_DECLARE;
 
    void *          data;
 
    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 );
    new_header->fragment_offset = header->fragment_offset + IP_HEADER_DATA_LENGTH( header ) / 8;
    new_header->header_checksum = IP_HEADER_CHECKSUM( new_header );
    ERROR_PROPAGATE( packet_set_addr( new_packet, src, dest, address_length ));
    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;
}
 
ip_header_ref ip_create_last_header( packet_t packet, ip_header_ref first ){
    ip_header_ref   last;
    ip_option_ref   option;
    size_t          next;
    size_t          length;
 
    // allocate as much as originally
    last = ( ip_header_ref ) packet_suffix( packet, IP_HEADER_LENGTH( first ));
    if( ! last ) return NULL;
    // 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->ihl ){
        option = ( ip_option_ref ) ((( void * ) 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((( void * ) last ) + length, (( void * ) first ) + next, option->length );
                length += option->length;
            }
            // next option
            next += option->length;
        }
    }
    // align 4 byte boundary
    if( length % 4 ){
        bzero((( void * ) last ) + length, 4 - ( length % 4 ));
        last->ihl = length / 4 + 1;
    }else{
        last->ihl = length / 4;
    }
    // trim the unused space
    if( packet_trim( packet, 0, IP_HEADER_LENGTH( first ) - IP_HEADER_LENGTH( last )) != EOK ) return NULL;
    return last;
}
 
int ip_received_msg( device_id_t device_id, packet_t packet ){
    packet_t        next;
 
    do{
        next = pq_detach( packet );
        if( ip_process_packet( device_id, packet ) != EOK ){
            pq_release( ip_globals.net_phone, packet_get_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;
 
    header = ( ip_header_ref ) packet_get_data( packet );
    if( ! header ) return ENOMEM;
    // checksum
    if(( header->header_checksum ) && ( IP_HEADER_CHECKSUM( header ))){
        // TODO checksum error ICMP?
        return EINVAL;
    }
    // TODO ttl oxceeded ICMP?
    if( !( -- header->ttl )) return EINVAL;
    // process ipopt and get destination
    dest = ip_get_destination( header );
    ERROR_PROPAGATE( packet_set_addr( packet, NULL, ( uint8_t * ) & dest.s_addr, IP_ADDR ));
    route = ip_find_route( dest );
    // TODO unreachable ICMP?
    if( ! route ) return ENOENT;
    if( route->address.s_addr == dest.s_addr ){
        // local delivery
        return ip_deliver_local( device_id, packet, header );
    }else{
        return ip_send_route( packet, route->netif, route, NULL, dest );
    }
}
 
int ip_deliver_local( device_id_t device_id, packet_t packet, ip_header_ref header ){
    ERROR_DECLARE;
 
    ip_proto_ref    proto;
 
    if(( header->flags & IPFLAG_MORE_FRAGMENTS ) || header->fragment_offset ){
        // TODO fragmented
        return ENOTSUP;
    }else{
        proto = ip_protos_find( & ip_globals.protos, header->protocol );
        if( ! proto ) return ENOENT;
        ERROR_PROPAGATE( packet_set_addr( packet, ( uint8_t * ) & header->source_address, ( uint8_t * ) & header->destination_address, IP_ADDR ));
        if( proto->tl_received_msg ){
            return proto->tl_received_msg( device_id, packet, SERVICE_IP );
        }else{
            return tl_received_msg( proto->phone, device_id, packet, proto->service );
        }
    }
}
 
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; //ntohl( header->destination_address );
    return destination;
}
 
/** @}
 */
 

Rev 4505	Rev 4506
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	*/	34	*/
35		35
36	#include <async.h>	36	#include <async.h>
37	#include <errno.h>	37	#include <errno.h>
38	#include <stdio.h>	38	#include <stdio.h>
39	#include <string.h>	39	#include <string.h>
40		40
41	#include <ipc/ipc.h>	41	#include <ipc/ipc.h>
42	#include <ipc/services.h>	42	#include <ipc/services.h>
43		43
44	#include <sys/types.h>	44	#include <sys/types.h>
45		45
46	#include "../../err.h"	46	#include "../../err.h"
47	#include "../../messages.h"	47	#include "../../messages.h"
48	#include "../../modules.h"	48	#include "../../modules.h"
49		49
50	#include "../../include/net_interface.h"	50	#include "../../include/net_interface.h"
51	#include "../../include/sockaddr.h"	51	#include "../../include/sockaddr.h"
52	#include "../../include/socket.h"	52	#include "../../include/socket.h"
53	#include "../../include/byteorder.h"	53	#include "../../include/byteorder.h"
54	#include "../../include/crc.h"	54	#include "../../include/crc.h"
55	#include "../../include/device.h"	55	#include "../../include/device.h"
56	#include "../../include/arp_interface.h"	56	#include "../../include/arp_interface.h"
57	#include "../../include/nil_interface.h"	57	#include "../../include/nil_interface.h"
58	#include "../../include/il_interface.h"	58	#include "../../include/il_interface.h"
59	#include "../../include/ip_client.h"	59	#include "../../include/ip_client.h"
60	#include "../../include/ip_interface.h"	60	#include "../../include/ip_interface.h"
61	#include "../../include/tl_interface.h"	61	#include "../../include/tl_interface.h"
62	#include "../../structures/measured_strings.h"	62	#include "../../structures/measured_strings.h"
63	#include "../../structures/module_map.h"	63	#include "../../structures/module_map.h"
64	#include "../../structures/packet/packet_client.h"	64	#include "../../structures/packet/packet_client.h"
65		65
66	#include "../../nil/nil_messages.h"	66	#include "../../nil/nil_messages.h"
67		67
68	#include "../il_messages.h"	68	#include "../il_messages.h"
69		69
70	#include "ip.h"	70	#include "ip.h"
71	#include "ip_header.h"	71	#include "ip_header.h"
72	#include "ip_messages.h"	72	#include "ip_messages.h"
73	#include "ip_module.h"	73	#include "ip_module.h"
74		74
75	#define DEFAULT_IPV 4	75	#define DEFAULT_IPV 4
76	#define IP_MIN_CONTENT 576	76	#define IP_MIN_CONTENT 576
77		77
78	#define ARP_NAME "arp"	78	#define ARP_NAME "arp"
79	#define ARP_FILENAME "/srv/arp"	79	#define ARP_FILENAME "/srv/arp"
80		80
81	#define IP_ADDR sizeof( in_addr_t )	81	#define IP_ADDR sizeof( in_addr_t )
82	#define IP_PREFIX sizeof( ip_header_t )	82	#define IP_PREFIX sizeof( ip_header_t )
83	#define IP_SUFFIX 0	83	#define IP_SUFFIX 0
84	#define IP_MAX_CONTENT 65535	84	#define IP_MAX_CONTENT 65535
85	#define IP_HEADER_LENGTH( header ) (( header )->ihl * 4 )	85	#define IP_HEADER_LENGTH( header ) (( header )->ihl * 4 )
86	#define IP_TOTAL_LENGTH( header ) ntohs(( header )->total_length )	86	#define IP_TOTAL_LENGTH( header ) ntohs(( header )->total_length )
87	#define IP_HEADER_DATA_LENGTH( header ) ( IP_TOTAL_LENGTH( header ) - IP_HEADER_LENGTH( header ))	87	#define IP_HEADER_DATA_LENGTH( header ) ( IP_TOTAL_LENGTH( header ) - IP_HEADER_LENGTH( header ))
88	#define IP_HEADER_CHECKSUM( header ) ( htons( ip_checksum(( uint8_t * )( header ), IP_HEADER_LENGTH( header ))))	88	#define IP_HEADER_CHECKSUM( header ) ( htons( ip_checksum(( uint8_t * )( header ), IP_HEADER_LENGTH( header ))))
89		89
90	//zero is returned as 0xFFFF (not flipped)	90	//zero is returned as 0xFFFF (not flipped)
91	#define IP_HEADER_CHECKSUM_ZERO 0xFFFF	91	#define IP_HEADER_CHECKSUM_ZERO 0xFFFF
92		92
93	ip_globals_t ip_globals;	93	ip_globals_t ip_globals;
94		94
95	DEVICE_MAP_IMPLEMENT( ip_netifs, ip_netif_t )	95	DEVICE_MAP_IMPLEMENT( ip_netifs, ip_netif_t )
96		96
97	INT_MAP_IMPLEMENT( ip_protos, ip_proto_t )	97	INT_MAP_IMPLEMENT( ip_protos, ip_proto_t )
98		98
99	GENERIC_FIELD_IMPLEMENT( ip_routes, ip_route_t )	99	GENERIC_FIELD_IMPLEMENT( ip_routes, ip_route_t )
100		100
101	int ip_device_state_msg( int il_phone, device_id_t device_id, device_state_t state );	101	int ip_device_state_msg( int il_phone, device_id_t device_id, device_state_t state );
102	int ip_register( int protocol, services_t service, int phone, tl_received_msg_t tl_received_msg );	102	int ip_register( int protocol, services_t service, int phone, tl_received_msg_t tl_received_msg );
103	int ip_netif_initialize( ip_netif_ref ip_netif );	103	int ip_netif_initialize( ip_netif_ref ip_netif );
104		104
105	int ip_send_route( packet_t packet, ip_netif_ref netif, ip_route_ref route, in_addr_t * src, in_addr_t dest );	105	int ip_send_route( packet_t packet, ip_netif_ref netif, ip_route_ref route, in_addr_t * src, in_addr_t dest );
106	int ip_prepare_packet( in_addr_t * source, packet_t packet, measured_string_ref destination );	106	int ip_prepare_packet( in_addr_t * source, packet_t packet, measured_string_ref destination );
107		107
108	packet_t ip_split_packet( packet_t packet, size_t prefix, size_t content, size_t suffix, size_t addr_len );	108	packet_t ip_split_packet( packet_t packet, size_t prefix, size_t content, size_t suffix, size_t addr_len );
109	int ip_fragment_packet( packet_t packet, size_t length, size_t prefix, size_t suffix, size_t addr_len );	109	int ip_fragment_packet( packet_t packet, size_t length, size_t prefix, size_t suffix, size_t addr_len );
110	int ip_fragment_packet_data( packet_t packet, packet_t new_packet, ip_header_ref header, ip_header_ref new_header, size_t length, void * src, void * dest, size_t address_length );	110	int ip_fragment_packet_data( packet_t packet, packet_t new_packet, ip_header_ref header, ip_header_ref new_header, size_t length, void * src, void * dest, size_t address_length );
111	ip_header_ref ip_create_middle_header( packet_t packet, ip_header_ref last );	111	ip_header_ref ip_create_middle_header( packet_t packet, ip_header_ref last );
112	ip_header_ref ip_create_last_header( packet_t packet, ip_header_ref first );	112	ip_header_ref ip_create_last_header( packet_t packet, ip_header_ref first );
113		113
114	in_addr_t * ip_netif_addr( ip_netif_ref netif );	114	in_addr_t * ip_netif_addr( ip_netif_ref netif );
115	ip_route_ref ip_find_route( in_addr_t destination );	115	ip_route_ref ip_find_route( in_addr_t destination );
116	ip_route_ref ip_netif_find_route( ip_netif_ref netif, in_addr_t destination );	116	ip_route_ref ip_netif_find_route( ip_netif_ref netif, in_addr_t destination );
117		117
118	int ip_received_msg( device_id_t device_id, packet_t packet );	118	int ip_received_msg( device_id_t device_id, packet_t packet );
119	int ip_process_packet( device_id_t device_id, packet_t packet );	119	int ip_process_packet( device_id_t device_id, packet_t packet );
120	in_addr_t ip_get_destination( ip_header_ref header );	120	in_addr_t ip_get_destination( ip_header_ref header );
121	int ip_deliver_local( device_id_t device_id, packet_t packet, ip_header_ref header );	121	int ip_deliver_local( device_id_t device_id, packet_t packet, ip_header_ref header );
122		122
123	/** Computes the ip header checksum.	123	/** Computes the ip header checksum.
124	* To compute the checksum of a new packet, the checksum header field must be zero.	124	* To compute the checksum of a new packet, the checksum header field must be zero.
125	* To check the checksum of a received packet, the checksum may be left set.	125	* To check the checksum of a received packet, the checksum may be left set.
126	* The zero (0) value will returned in this case if valid.	126	* The zero (0) value will returned in this case if valid.
127	* @param data The header data. Input parameter.	127	* @param data The header data. Input parameter.
128	* @param length The header length in bytes. Input parameter.	128	* @param length The header length in bytes. Input parameter.
129	* @returns The internet protocol header checksum.	129	* @returns The internet protocol header checksum.
130	* @returns IP_HEADER_CHECKSUM_ZERO if the computed checksum is zero.	130	* @returns IP_HEADER_CHECKSUM_ZERO if the computed checksum is zero.
131	*/	131	*/
132	uint16_t ip_checksum( uint8_t * data, int length );	132	uint16_t ip_checksum( uint8_t * data, int length );
133		133
134	uint16_t ip_checksum( uint8_t * data, int length ){	134	uint16_t ip_checksum( uint8_t * data, int length ){
135	uint16_t checksum;	135	uint16_t checksum;
136		136
137	checksum = compact_checksum(compute_checksum( 0, data, length ));	137	checksum = compact_checksum(compute_checksum( 0, data, length ));
138		138
139	// flip, zero is returned as 0xFFFF (not flipped)	139	// flip, zero is returned as 0xFFFF (not flipped)
140	return ( ~ checksum ) ? ~ checksum : IP_HEADER_CHECKSUM_ZERO;	140	return ( ~ checksum ) ? ~ checksum : IP_HEADER_CHECKSUM_ZERO;
141	}	141	}
142		142
143	/** Initializes the module.	143	/** Initializes the module.
144	*/	144	*/
145	int ip_initialize( async_client_conn_t client_connection ){	145	int ip_initialize( async_client_conn_t client_connection ){
146	ERROR_DECLARE;	146	ERROR_DECLARE;
147		147
148	ip_globals.packet_counter = 0;	148	ip_globals.packet_counter = 0;
149	ip_globals.gateway.address.s_addr = 0;	149	ip_globals.gateway.address.s_addr = 0;
150	ip_globals.gateway.netmask.s_addr = 0;	150	ip_globals.gateway.netmask.s_addr = 0;
151	ip_globals.gateway.gateway.s_addr = 0;	151	ip_globals.gateway.gateway.s_addr = 0;
152	ip_globals.gateway.netif = NULL;	152	ip_globals.gateway.netif = NULL;
153	ERROR_PROPAGATE( ip_netifs_initialize( & ip_globals.netifs ));	153	ERROR_PROPAGATE( ip_netifs_initialize( & ip_globals.netifs ));
154	ERROR_PROPAGATE( ip_protos_initialize( & ip_globals.protos ));	154	ERROR_PROPAGATE( ip_protos_initialize( & ip_globals.protos ));
155	ip_globals.client_connection = client_connection;	155	ip_globals.client_connection = client_connection;
156	ERROR_PROPAGATE( modules_initialize( & ip_globals.modules ));	156	ERROR_PROPAGATE( modules_initialize( & ip_globals.modules ));
157	ERROR_PROPAGATE( add_module( NULL, & ip_globals.modules, ARP_NAME, ARP_FILENAME, SERVICE_ARP, arp_task_get_id(), arp_connect_module ));	157	ERROR_PROPAGATE( add_module( NULL, & ip_globals.modules, ARP_NAME, ARP_FILENAME, SERVICE_ARP, arp_task_get_id(), arp_connect_module ));
158	return EOK;	158	return EOK;
159	}	159	}
160		160
161	int ip_device_req( int il_phone, device_id_t device_id, services_t netif ){	161	int ip_device_req( int il_phone, device_id_t device_id, services_t netif ){
162	ERROR_DECLARE;	162	ERROR_DECLARE;
163		163
164	ip_netif_ref ip_netif;	164	ip_netif_ref ip_netif;
165	ip_route_ref route;	165	ip_route_ref route;
166	int index;	166	int index;
167	char * data;	167	char * data;
168		168
169	ip_netif = ( ip_netif_ref ) malloc( sizeof( ip_netif_t ));	169	ip_netif = ( ip_netif_ref ) malloc( sizeof( ip_netif_t ));
170	if( ! ip_netif ) return ENOMEM;	170	if( ! ip_netif ) return ENOMEM;
171	if( ERROR_OCCURRED( ip_routes_initialize( & ip_netif->routes ))){	171	if( ERROR_OCCURRED( ip_routes_initialize( & ip_netif->routes ))){
172	free( ip_netif );	172	free( ip_netif );
173	return ERROR_CODE;	173	return ERROR_CODE;
174	}	174	}
175	ip_netif->device_id = device_id;	175	ip_netif->device_id = device_id;
176	ip_netif->service = netif;	176	ip_netif->service = netif;
177	ip_netif->state = NETIF_STOPPED;	177	ip_netif->state = NETIF_STOPPED;
178	if( ERROR_OCCURRED( ip_netif_initialize( ip_netif ))){	178	if( ERROR_OCCURRED( ip_netif_initialize( ip_netif ))){
179	ip_routes_destroy( & ip_netif->routes );	179	ip_routes_destroy( & ip_netif->routes );
180	free( ip_netif );	180	free( ip_netif );
181	return ERROR_CODE;	181	return ERROR_CODE;
182	}	182	}
183	if( ip_netif->arp ) ++ ip_netif->arp->usage;	183	if( ip_netif->arp ) ++ ip_netif->arp->usage;
184	// print the settings	184	// print the settings
185	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 );	185	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 );
186	printf( "\tconfiguration\t= %s\n", ip_netif->dhcp ? "dhcp" : "static" );	186	printf( "\tconfiguration\t= %s\n", ip_netif->dhcp ? "dhcp" : "static" );
187	// TODO ipv6 addresses	187	// TODO ipv6 addresses
188	data = ( char * ) malloc( INET_ADDRSTRLEN );	188	data = ( char * ) malloc( INET_ADDRSTRLEN );
189	if( data ){	189	if( data ){
190	for( index = 0; index < ip_routes_count( & ip_netif->routes ); ++ index ){	190	for( index = 0; index < ip_routes_count( & ip_netif->routes ); ++ index ){
191	route = ip_routes_get_index( & ip_netif->routes, index );	191	route = ip_routes_get_index( & ip_netif->routes, index );
192	if( route ){	192	if( route ){
193	printf( "\tRouting %d:\n", index );	193	printf( "\tRouting %d:\n", index );
194	inet_ntop( AF_INET, ( uint8_t * ) & route->address.s_addr, data, INET_ADDRSTRLEN );	194	inet_ntop( AF_INET, ( uint8_t * ) & route->address.s_addr, data, INET_ADDRSTRLEN );
195	printf( "\t\taddress\t= %s\n", data );	195	printf( "\t\taddress\t= %s\n", data );
196	inet_ntop( AF_INET, ( uint8_t * ) & route->netmask.s_addr, data, INET_ADDRSTRLEN );	196	inet_ntop( AF_INET, ( uint8_t * ) & route->netmask.s_addr, data, INET_ADDRSTRLEN );
197	printf( "\t\tnetmask\t= %s\n", data );	197	printf( "\t\tnetmask\t= %s\n", data );
198	inet_ntop( AF_INET, ( uint8_t * ) & route->gateway.s_addr, data, INET_ADDRSTRLEN );	198	inet_ntop( AF_INET, ( uint8_t * ) & route->gateway.s_addr, data, INET_ADDRSTRLEN );
199	printf( "\t\tgateway\t= %s\n", data );	199	printf( "\t\tgateway\t= %s\n", data );
200	}	200	}
201	}	201	}
202	inet_ntop( AF_INET, ( uint8_t * ) & ip_netif->broadcast.s_addr, data, INET_ADDRSTRLEN );	202	inet_ntop( AF_INET, ( uint8_t * ) & ip_netif->broadcast.s_addr, data, INET_ADDRSTRLEN );
203	printf( "\tbroadcast\t= %s\n", data );	203	printf( "\tbroadcast\t= %s\n", data );
204	inet_ntop( AF_INET, ( uint8_t * ) & ip_netif->dns1, data, INET_ADDRSTRLEN );	204	inet_ntop( AF_INET, ( uint8_t * ) & ip_netif->dns1, data, INET_ADDRSTRLEN );
205	printf( "\tdns1\t= %s\n", data );	205	printf( "\tdns1\t= %s\n", data );
206	inet_ntop( AF_INET, ( uint8_t * ) & ip_netif->dns2, data, INET_ADDRSTRLEN );	206	inet_ntop( AF_INET, ( uint8_t * ) & ip_netif->dns2, data, INET_ADDRSTRLEN );
207	printf( "\tdns2\t= %s\n", data );	207	printf( "\tdns2\t= %s\n", data );
208	free( data );	208	free( data );
209	}	209	}
210	return EOK;	210	return EOK;
211	}	211	}
212		212
213	int ip_netif_initialize( ip_netif_ref ip_netif ){	213	int ip_netif_initialize( ip_netif_ref ip_netif ){
214	ERROR_DECLARE;	214	ERROR_DECLARE;
215		215
216	measured_string_t names[ 9 ] = {{ "IPV", 3 }, { "IP_CONFIG", 9 }, { "IP_ADDR", 7 }, { "NETMASK", 7 }, { "GATEWAY", 7 }, { "BROADCAST", 9 }, { "DNS1", 4 }, { "DNS2", 4 }, { "ARP", 3 }};	216	measured_string_t names[ 9 ] = {{ "IPV", 3 }, { "IP_CONFIG", 9 }, { "IP_ADDR", 7 }, { "NETMASK", 7 }, { "GATEWAY", 7 }, { "BROADCAST", 9 }, { "DNS1", 4 }, { "DNS2", 4 }, { "ARP", 3 }};
217	measured_string_ref configuration;	217	measured_string_ref configuration;
218	size_t count = sizeof( names ) / sizeof( measured_string_t );	218	size_t count = sizeof( names ) / sizeof( measured_string_t );
219	char * data;	219	char * data;
220	int index;	220	int index;
221	ip_route_ref route;	221	ip_route_ref route;
222	in_addr_t gateway;	222	in_addr_t gateway;
223		223
-		224	ip_netif->arp = 0;
-		225	route = NULL;
224	configuration = & names[ 0 ];	226	configuration = & names[ 0 ];
225	// get configuration	227	// get configuration
226	ERROR_PROPAGATE( net_get_device_conf_req( ip_globals.net_phone, ip_netif->device_id, & configuration, count, & data ));	228	ERROR_PROPAGATE( net_get_device_conf_req( ip_globals.net_phone, ip_netif->device_id, & configuration, count, & data ));
227	if( configuration ){	229	if( configuration ){
228	if( configuration[ 0 ].value ){	230	if( configuration[ 0 ].value ){
229	ip_netif->ipv = strtol( configuration[ 0 ].value, NULL, 0 );	231	ip_netif->ipv = strtol( configuration[ 0 ].value, NULL, 0 );
230	}else{	232	}else{
231	ip_netif->ipv = DEFAULT_IPV;	233	ip_netif->ipv = DEFAULT_IPV;
232	}	234	}
233	ip_netif->dhcp = ! str_lcmp( configuration[ 1 ].value, "dhcp", configuration[ 1 ].length );	235	ip_netif->dhcp = ! str_lcmp( configuration[ 1 ].value, "dhcp", configuration[ 1 ].length );
234	if( ip_netif->dhcp ){	236	if( ip_netif->dhcp ){
235	// TODO dhcp	237	// TODO dhcp
236	net_free_settings( configuration, data );	238	net_free_settings( configuration, data );
237	return ENOTSUP;	239	return ENOTSUP;
238	}else if( ip_netif->ipv == 4 ){	240	}else if( ip_netif->ipv == 4 ){
239	route = ( ip_route_ref ) malloc( sizeof( ip_route_t ));	241	route = ( ip_route_ref ) malloc( sizeof( ip_route_t ));
240	if( ! route ){	242	if( ! route ){
241	net_free_settings( configuration, data );	243	net_free_settings( configuration, data );
242	return ENOMEM;	244	return ENOMEM;
243	}	245	}
244	route->address.s_addr = 0;	246	route->address.s_addr = 0;
245	route->netmask.s_addr = 0;	247	route->netmask.s_addr = 0;
246	route->gateway.s_addr = 0;	248	route->gateway.s_addr = 0;
247	route->netif = ip_netif;	249	route->netif = ip_netif;
248	index = ip_routes_add( & ip_netif->routes, route );	250	index = ip_routes_add( & ip_netif->routes, route );
249	if( index < 0 ){	251	if( index < 0 ){
250	net_free_settings( configuration, data );	252	net_free_settings( configuration, data );
251	free( route );	253	free( route );
252	return index;	254	return index;
253	}	255	}
254	if( ERROR_OCCURRED( inet_pton( AF_INET, configuration[ 2 ].value, ( uint8_t * ) & route->address.s_addr ))	256	if( ERROR_OCCURRED( inet_pton( AF_INET, configuration[ 2 ].value, ( uint8_t * ) & route->address.s_addr ))
255	\|\| ERROR_OCCURRED( inet_pton( AF_INET, configuration[ 3 ].value, ( uint8_t * ) & route->netmask.s_addr ))	257	\|\| ERROR_OCCURRED( inet_pton( AF_INET, configuration[ 3 ].value, ( uint8_t * ) & route->netmask.s_addr ))
256	\|\| ( inet_pton( AF_INET, configuration[ 4 ].value, ( uint8_t * ) & gateway.s_addr ) == EINVAL )	258	\|\| ( inet_pton( AF_INET, configuration[ 4 ].value, ( uint8_t * ) & gateway.s_addr ) == EINVAL )
257	\|\| ( inet_pton( AF_INET, configuration[ 5 ].value, ( uint8_t * ) & ip_netif->broadcast.s_addr ) == EINVAL )	259	\|\| ( inet_pton( AF_INET, configuration[ 5 ].value, ( uint8_t * ) & ip_netif->broadcast.s_addr ) == EINVAL )
258	\|\| ( inet_pton( AF_INET, configuration[ 6 ].value, ( uint8_t * ) & ip_netif->dns1 ) == EINVAL )	260	\|\| ( inet_pton( AF_INET, configuration[ 6 ].value, ( uint8_t * ) & ip_netif->dns1 ) == EINVAL )
259	\|\| ( inet_pton( AF_INET, configuration[ 7 ].value, ( uint8_t * ) & ip_netif->dns2 ) == EINVAL )){	261	\|\| ( inet_pton( AF_INET, configuration[ 7 ].value, ( uint8_t * ) & ip_netif->dns2 ) == EINVAL )){
260	net_free_settings( configuration, data );	262	net_free_settings( configuration, data );
261	return EINVAL;	263	return EINVAL;
262	}	264	}
263	}else{	265	}else{
264	// TODO ipv6 in separate module	266	// TODO ipv6 in separate module
265	net_free_settings( configuration, data );	267	net_free_settings( configuration, data );
266	return ENOTSUP;	268	return ENOTSUP;
267	}	269	}
268	if( configuration[ 8 ].value ){	270	if( configuration[ 8 ].value ){
269	ip_netif->arp = get_running_module( & ip_globals.modules, configuration[ 8 ].value );	271	ip_netif->arp = get_running_module( & ip_globals.modules, configuration[ 8 ].value );
270	if( ! ip_netif->arp ){	272	if( ! ip_netif->arp ){
271	printf( "Failed to start the arp %s\n", configuration[ 8 ].value );	273	printf( "Failed to start the arp %s\n", configuration[ 8 ].value );
272	net_free_settings( configuration, data );	274	net_free_settings( configuration, data );
273	return EINVAL;	275	return EINVAL;
274	}	276	}
275	}else{	277	}else{
276	ip_netif->arp = NULL;	278	ip_netif->arp = NULL;
277	}	279	}
278	net_free_settings( configuration, data );	280	net_free_settings( configuration, data );
279	}	281	}
280	ip_netif->phone = bind_service( ip_netif->service, ip_netif->device_id, SERVICE_IP, 0, ip_globals.client_connection );	282	ip_netif->phone = bind_service( ip_netif->service, ip_netif->device_id, SERVICE_IP, 0, ip_globals.client_connection );
281	if( ip_netif->phone < 0 ){	283	if( ip_netif->phone < 0 ){
282	printf( "Failed to contact the nil service %d\n", ip_netif->service );	284	printf( "Failed to contact the nil service %d\n", ip_netif->service );
283	return ip_netif->phone;	285	return ip_netif->phone;
284	}	286	}
285	// MUST BE AFTER the bind_service up there!	287	// MUST BE AFTER the bind_service up there!
286	if( ip_netif->arp ){	288	if( ip_netif->arp ){
-		289	if( route ){
287	configuration[ 0 ].value = ( char * ) & route->address.s_addr;	290	configuration[ 0 ].value = ( char * ) & route->address.s_addr;
288	configuration[ 0 ].length = CONVERT_SIZE( in_addr_t, char, 1 );	291	configuration[ 0 ].length = CONVERT_SIZE( in_addr_t, char, 1 );
289	ERROR_PROPAGATE( arp_device_req( ip_netif->arp->phone, ip_netif->device_id, SERVICE_IP, ip_netif->service, & configuration[ 0 ] ));	292	ERROR_PROPAGATE( arp_device_req( ip_netif->arp->phone, ip_netif->device_id, SERVICE_IP, ip_netif->service, & configuration[ 0 ] ));
-		293	}else{
-		294	ip_netif->arp = 0;
-		295	}
290	}	296	}
291	// get packet dimensions	297	// get packet dimensions
292	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 ));	298	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 ));
293	if( ip_netif->content < IP_MIN_CONTENT ){	299	if( ip_netif->content < IP_MIN_CONTENT ){
294	printf( "Maximum transmission unit %d bytes is too small, at least %d bytes are needed\n", ip_netif->content, IP_MIN_CONTENT );	300	printf( "Maximum transmission unit %d bytes is too small, at least %d bytes are needed\n", ip_netif->content, IP_MIN_CONTENT );
295	ip_netif->content = IP_MIN_CONTENT;	301	ip_netif->content = IP_MIN_CONTENT;
296	}	302	}
297	index = ip_netifs_add( & ip_globals.netifs, ip_netif->device_id, ip_netif );	303	index = ip_netifs_add( & ip_globals.netifs, ip_netif->device_id, ip_netif );
298	if( index < 0 ) return index;	304	if( index < 0 ) return index;
299	if( gateway.s_addr ){	305	if( gateway.s_addr ){
300	// the default gateway	306	// the default gateway
301	ip_globals.gateway.address.s_addr = 0;	307	ip_globals.gateway.address.s_addr = 0;
302	ip_globals.gateway.netmask.s_addr = 0;	308	ip_globals.gateway.netmask.s_addr = 0;
303	ip_globals.gateway.gateway.s_addr = gateway.s_addr;	309	ip_globals.gateway.gateway.s_addr = gateway.s_addr;
304	ip_globals.gateway.netif = ip_netif;	310	ip_globals.gateway.netif = ip_netif;
305	}	311	}
306	return EOK;	312	return EOK;
307	}	313	}
308		314
309	int ip_device_state_msg( int il_phone, device_id_t device_id, device_state_t state ){	315	int ip_device_state_msg( int il_phone, device_id_t device_id, device_state_t state ){
310	ERROR_DECLARE;	316	// ERROR_DECLARE;
311		317
312	/* measured_string_t address;	318	/* measured_string_t address;
313	measured_string_ref translation;	319	measured_string_ref translation;
314	char * data;	320	char * data;
315	*/	321	*/
316	packet_t packet;	322	/* packet_t packet;
317	in_addr_t destination;	323	in_addr_t destination;
318		324	*/
319	ip_netif_ref netif;	325	ip_netif_ref netif;
320		326
321	netif = ip_netifs_find( & ip_globals.netifs, device_id );	327	netif = ip_netifs_find( & ip_globals.netifs, device_id );
322	if( ! netif ) return ENOENT;	328	if( ! netif ) return ENOENT;
323	netif->state = state;	329	netif->state = state;
324	// TODO state	330	// TODO state
325	printf( "ip - device %d changed state to %d\n\n", device_id, state );	331	printf( "ip - device %d changed state to %d\n\n", device_id, state );
326	if( netif->arp ){	332	// if( netif->arp ){
327	/* address.value = ( char * ) & ip_globals.gateway.gateway.s_addr;	333	/* address.value = ( char * ) & ip_globals.gateway.gateway.s_addr;
328	address.length = CONVERT_SIZE( ip_globals.gateway.gateway.s_addr, char, 1 );	334	address.length = CONVERT_SIZE( ip_globals.gateway.gateway.s_addr, char, 1 );
329	if( ERROR_OCCURRED( arp_translate_req( netif->arp->phone, netif->device_id, SERVICE_IP, & address, & translation, & data ))){	335	if( ERROR_OCCURRED( arp_translate_req( netif->arp->phone, netif->device_id, SERVICE_IP, & address, & translation, & data ))){
330	ERROR_PROPAGATE( arp_translate_req( netif->arp->phone, netif->device_id, SERVICE_IP, & address, & translation, & data ));	336	ERROR_PROPAGATE( arp_translate_req( netif->arp->phone, netif->device_id, SERVICE_IP, & address, & translation, & data ));
331	}	337	}
332	printf( "\tgateway translated to\t= %X:%X:%X:%X:%X:%X\n", data[ 0 ], data[ 1 ], data[ 2 ], data[ 3 ], data[ 4 ], data[ 5 ] );	338	printf( "\tgateway translated to\t= %X:%X:%X:%X:%X:%X\n", data[ 0 ], data[ 1 ], data[ 2 ], data[ 3 ], data[ 4 ], data[ 5 ] );
333	free( translation );	339	free( translation );
334	free( data );	340	free( data );
335	address.value = ( char * ) & ip_globals.gateway.gateway.s_addr;	341	address.value = ( char * ) & ip_globals.gateway.gateway.s_addr;
336	address.length = CONVERT_SIZE( ip_globals.gateway.gateway.s_addr, char, 1 );	342	address.length = CONVERT_SIZE( ip_globals.gateway.gateway.s_addr, char, 1 );
337	if( ERROR_OCCURRED( arp_translate_req( netif->arp->phone, netif->device_id, SERVICE_IP, & address, & translation, & data ))){	343	if( ERROR_OCCURRED( arp_translate_req( netif->arp->phone, netif->device_id, SERVICE_IP, & address, & translation, & data ))){
338	sleep( 2 );	344	sleep( 2 );
339	ERROR_PROPAGATE( arp_translate_req( netif->arp->phone, netif->device_id, SERVICE_IP, & address, & translation, & data ));	345	ERROR_PROPAGATE( arp_translate_req( netif->arp->phone, netif->device_id, SERVICE_IP, & address, & translation, & data ));
340	}	346	}
341	printf( "\tgateway translated to\t= %X:%X:%X:%X:%X:%X\n", data[ 0 ], data[ 1 ], data[ 2 ], data[ 3 ], data[ 4 ], data[ 5 ] );	347	printf( "\tgateway translated to\t= %X:%X:%X:%X:%X:%X\n", data[ 0 ], data[ 1 ], data[ 2 ], data[ 3 ], data[ 4 ], data[ 5 ] );
342	free( translation );	348	free( translation );
343	free( data );	349	free( data );
344	*/ printf( "IP - testing to send packet:\n" );	350	// printf( "IP - testing to send packet:\n" );
345	ERROR_PROPAGATE( inet_pton( AF_INET, "90.182.101.18", ( uint8_t * ) & destination.s_addr ));	351	ERROR_PROPAGATE( inet_pton( AF_INET, "90.182.101.18", ( uint8_t * ) & destination.s_addr ));
346	packet = packet_get_4( ip_globals.net_phone, 30, netif->addr_len, netif->prefix + sizeof( ip_header_t ), netif->suffix );	352	packet = packet_get_4( ip_globals.net_phone, 30, netif->addr_len, netif->prefix + sizeof( ip_header_t ), netif->suffix );
347	if( ! packet ) return ENOMEM;	353	if( ! packet ) return ENOMEM;
348	pq_release( ip_globals.net_phone, packet_get_id( packet ));	354	pq_release( ip_globals.net_phone, packet_get_id( packet ));
349	packet = packet_get_4( ip_globals.net_phone, 30, netif->addr_len, netif->prefix + sizeof( ip_header_t ), netif->suffix );	355	packet = packet_get_4( ip_globals.net_phone, 30, netif->addr_len, netif->prefix + sizeof( ip_header_t ), netif->suffix );
350	if( ! packet ) return ENOMEM;	356	if( ! packet ) return ENOMEM;
351	pq_release( ip_globals.net_phone, packet_get_id( packet ));	357	pq_release( ip_globals.net_phone, packet_get_id( packet ));
352	packet = packet_get_4( ip_globals.net_phone, 30, netif->addr_len, netif->prefix + sizeof( ip_header_t ), netif->suffix );	358	packet = packet_get_4( ip_globals.net_phone, 30, netif->addr_len, netif->prefix + sizeof( ip_header_t ), netif->suffix );
353	if( ! packet ) return ENOMEM;	359	if( ! packet ) return ENOMEM;
354	pq_release( ip_globals.net_phone, packet_get_id( packet ));	360	pq_release( ip_globals.net_phone, packet_get_id( packet ));
355	packet = packet_get_4( ip_globals.net_phone, 1500, netif->addr_len, netif->prefix + sizeof( ip_header_t ), netif->suffix );	361	packet = packet_get_4( ip_globals.net_phone, 1500, netif->addr_len, netif->prefix + sizeof( ip_header_t ), netif->suffix );
356	if( ! packet ) return ENOMEM;	362	if( ! packet ) return ENOMEM;
357	// try this long version	363	// try this long version
358	// 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 ))	364	// 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 ))
359	if( ERROR_OCCURRED( packet_copy_data( packet, "Hi, this is IP", 14 ))	365	if( ERROR_OCCURRED( packet_copy_data( packet, "Hi, this is IP", 14 ))
360	\|\| ERROR_OCCURRED( packet_set_addr( packet, NULL, ( uint8_t * ) & destination.s_addr, 4 ))	366	\|\| ERROR_OCCURRED( packet_set_addr( packet, NULL, ( uint8_t * ) & destination.s_addr, 4 ))
361	\|\| ERROR_OCCURRED( ip_client_prepare_packet( packet, 0, 0, 0, 0, 0 ))){	367	\|\| ERROR_OCCURRED( ip_client_prepare_packet( packet, 0, 0, 0, 0, 0 ))){
362	pq_release( ip_globals.net_phone, packet_get_id( packet ));	368	pq_release( ip_globals.net_phone, packet_get_id( packet ));
363	}	369	}
364	ERROR_CODE = ip_send_msg( 0, 0, packet, SERVICE_IP );	370	ERROR_CODE = ip_send_msg( 0, 0, packet, SERVICE_IP );
365	printf( "send returned %d\n", ERROR_CODE );	371	printf( "send returned %d\n", ERROR_CODE );
366	}	372	}
367	return EOK;	373	*/ return EOK;
368	}	374	}
369		375
370	int ip_connect_module( services_t service ){	376	int ip_connect_module( services_t service ){
371	return EOK;	377	return EOK;
372	}	378	}
373		379
374	int ip_bind_service( services_t service, int protocol, services_t me, async_client_conn_t receiver, tl_received_msg_t tl_received_msg ){	380	int ip_bind_service( services_t service, int protocol, services_t me, async_client_conn_t receiver, tl_received_msg_t tl_received_msg ){
375	return ip_register( protocol, me, 0, tl_received_msg );	381	return ip_register( protocol, me, 0, tl_received_msg );
376	}	382	}
377		383
378	int ip_register( int protocol, services_t service, int phone, tl_received_msg_t tl_received_msg ){	384	int ip_register( int protocol, services_t service, int phone, tl_received_msg_t tl_received_msg ){
379	ip_proto_ref proto;	385	ip_proto_ref proto;
380	int index;	386	int index;
381		387
382	if( !( protocol && service && (( phone > 0 ) \|\| ( tl_received_msg )))) return EINVAL;	388	if( !( protocol && service && (( phone > 0 ) \|\| ( tl_received_msg )))) return EINVAL;
383	proto = ( ip_proto_ref ) malloc( sizeof( ip_protos_t ));	389	proto = ( ip_proto_ref ) malloc( sizeof( ip_protos_t ));
384	if( ! proto ) return ENOMEM;	390	if( ! proto ) return ENOMEM;
385	proto->protocol = protocol;	391	proto->protocol = protocol;
386	proto->service = service;	392	proto->service = service;
387	proto->phone = phone;	393	proto->phone = phone;
388	proto->tl_received_msg = tl_received_msg;	394	proto->tl_received_msg = tl_received_msg;
389	index = ip_protos_add( & ip_globals.protos, proto->protocol, proto );	395	index = ip_protos_add( & ip_globals.protos, proto->protocol, proto );
390	if( index < 0 ){	396	if( index < 0 ){
391	free( proto );	397	free( proto );
392	return index;	398	return index;
393	}	399	}
394	printf( "New protocol registered:\n\tprotocol\t= %d\n\tphone\t= %d\n", proto->protocol, proto->phone );	400	printf( "New protocol registered:\n\tprotocol\t= %d\n\tphone\t= %d\n", proto->protocol, proto->phone );
395	return EOK;	401	return EOK;
396	}	402	}
397		403
398	int ip_send_msg( int il_phone, device_id_t device_id, packet_t packet, services_t sender ){	404	int ip_send_msg( int il_phone, device_id_t device_id, packet_t packet, services_t sender ){
399	ERROR_DECLARE;	405	ERROR_DECLARE;
400		406
401	int length;	407	int length;
402	ip_netif_ref netif;	408	ip_netif_ref netif;
403	ip_route_ref route;	409	ip_route_ref route;
404	in_addr_t dest;	410	in_addr_t dest;
405	in_addr_t * src;	411	in_addr_t * src;
406		412
407	// addresses in the host byte order	413	// addresses in the host byte order
408	// should be the next hop address or the target destination address	414	// should be the next hop address or the target destination address
409	length = packet_get_addr( packet, NULL, ( void * )( & dest.s_addr ));	415	length = packet_get_addr( packet, NULL, ( void * )( & dest.s_addr ));
410	if( length < 0 ){	416	if( length < 0 ){
411	pq_release( ip_globals.net_phone, packet_get_id( packet ));	417	pq_release( ip_globals.net_phone, packet_get_id( packet ));
412	return length;	418	return length;
413	}	419	}
414	// TODO IPv6	420	// TODO IPv6
415	if( length != IP_ADDR ){	421	if( length != IP_ADDR ){
416	pq_release( ip_globals.net_phone, packet_get_id( packet ));	422	pq_release( ip_globals.net_phone, packet_get_id( packet ));
417	return EINVAL;	423	return EINVAL;
418	}	424	}
419	// rwlock_read_lock( & ip_globals.devices_lock );	425	// rwlock_read_lock( & ip_globals.devices_lock );
420	// device specified?	426	// device specified?
421	// dest.s_addr = ntohl( dest.s_addr );	427	// dest.s_addr = ntohl( dest.s_addr );
422	if( device_id ){	428	if( device_id ){
423	netif = ip_netifs_find( & ip_globals.netifs, device_id );	429	netif = ip_netifs_find( & ip_globals.netifs, device_id );
424	route = ip_netif_find_route( netif, dest );	430	route = ip_netif_find_route( netif, dest );
425	}else{	431	}else{
426	// TODO IPv6	432	// TODO IPv6
427	route = ip_find_route( dest );	433	route = ip_find_route( dest );
428	netif = route ? route->netif : NULL;	434	netif = route ? route->netif : NULL;
429	}	435	}
430	if( !( netif && route )){	436	if( !( netif && route )){
431	// rwlock_read_unlock( & ip_globals.devices_lock );	437	// rwlock_read_unlock( & ip_globals.devices_lock );
432	pq_release( ip_globals.net_phone, packet_get_id( packet ));	438	pq_release( ip_globals.net_phone, packet_get_id( packet ));
433	return ENOENT;	439	return ENOENT;
434	}	440	}
435	// to me?	441	// to me?
436	if( route->address.s_addr == dest.s_addr ){	442	if( route->address.s_addr == dest.s_addr ){
437	// TODO loopback deliver	443	// TODO loopback deliver
438	}	444	}
439		445
440	src = ip_netif_addr( netif );	446	src = ip_netif_addr( netif );
441	if( ! src ){	447	if( ! src ){
442	pq_release( ip_globals.net_phone, packet_get_id( packet ));	448	pq_release( ip_globals.net_phone, packet_get_id( packet ));
443	return ENOENT;	449	return ENOENT;
444	}	450	}
445	if( ERROR_OCCURRED( ip_send_route( packet, netif, route, src, dest ))){	451	if( ERROR_OCCURRED( ip_send_route( packet, netif, route, src, dest ))){
446	pq_release( ip_globals.net_phone, packet_get_id( packet ));	452	pq_release( ip_globals.net_phone, packet_get_id( packet ));
447	}	453	}
448	return ERROR_CODE;	454	return ERROR_CODE;
449	}	455	}
450		456
451	in_addr_t * ip_netif_addr( ip_netif_ref netif ){	457	in_addr_t * ip_netif_addr( ip_netif_ref netif ){
452	ip_route_ref route;	458	ip_route_ref route;
453		459
454	route = ip_routes_get_index( & netif->routes, 0 );	460	route = ip_routes_get_index( & netif->routes, 0 );
455	return route ? & route->address : NULL;	461	return route ? & route->address : NULL;
456	}	462	}
457		463
458	int ip_send_route( packet_t packet, ip_netif_ref netif, ip_route_ref route, in_addr_t * src, in_addr_t dest ){	464	int ip_send_route( packet_t packet, ip_netif_ref netif, ip_route_ref route, in_addr_t * src, in_addr_t dest ){
459	ERROR_DECLARE;	465	ERROR_DECLARE;
460		466
461	packet_t next;	467	packet_t next;
462	packet_t tmp;	468	packet_t tmp;
463	measured_string_t destination;	469	measured_string_t destination;
464	measured_string_ref translation;	470	measured_string_ref translation;
465	char * data;	471	char * data;
466		472
467	if( route->gateway.s_addr ){	473	if( route->gateway.s_addr ){
468	dest.s_addr = route->gateway.s_addr;	474	dest.s_addr = route->gateway.s_addr;
469	}	475	}
470	// get destination hardware address	476	// get destination hardware address
471	if( netif->arp ){	477	if( netif->arp ){
472	destination.value = ( char * ) & dest.s_addr;	478	destination.value = ( char * ) & dest.s_addr;
473	destination.length = CONVERT_SIZE( dest.s_addr, char, 1 );	479	destination.length = CONVERT_SIZE( dest.s_addr, char, 1 );
474	if( ERROR_OCCURRED( arp_translate_req( netif->arp->phone, netif->device_id, SERVICE_IP, & destination, & translation, & data ))){	480	if( ERROR_OCCURRED( arp_translate_req( netif->arp->phone, netif->device_id, SERVICE_IP, & destination, & translation, & data ))){
475	usleep( 200000 );	481	usleep( 200000 );
476	ERROR_PROPAGATE( arp_translate_req( netif->arp->phone, netif->device_id, SERVICE_IP, & destination, & translation, & data ));	482	ERROR_PROPAGATE( arp_translate_req( netif->arp->phone, netif->device_id, SERVICE_IP, & destination, & translation, & data ));
477	}	483	}
478	// TODO unreachable	484	// TODO unreachable
479	if( ! translation ) return EINVAL;	485	if( ! translation ) return EINVAL;
480	if( ! translation->value ){	486	if( ! translation->value ){
481	// TODO unreachable	487	// TODO unreachable
482	free( translation );	488	free( translation );
483	free( data );	489	free( data );
484	return EINVAL;	490	return EINVAL;
485	}	491	}
486	}else translation = NULL;	492	}else translation = NULL;
487	// process packet queue	493	// process packet queue
488	next = packet;	494	next = packet;
489	do{	495	do{
490	if( ERROR_OCCURRED( ip_prepare_packet( src, next, translation ))){	496	if( ERROR_OCCURRED( ip_prepare_packet( src, next, translation ))){
491	// release invalid packet	497	// release invalid packet
492	tmp = pq_detach( next );	498	tmp = pq_detach( next );
493	if( next == packet ) packet = tmp;	499	if( next == packet ) packet = tmp;
494	pq_release( ip_globals.net_phone, packet_get_id( next ));	500	pq_release( ip_globals.net_phone, packet_get_id( next ));

Subversion Repositories HelenOS

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