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


/*
 * Copyright (c) 2009 Lukas Mejdrech
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * - Redistributions of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 * - Redistributions in binary form must reproduce the above copyright
 *   notice, this list of conditions and the following disclaimer in the
 *   documentation and/or other materials provided with the distribution.
 * - The name of the author may not be used to endorse or promote products
 *   derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
/** @addtogroup ip
 *  @{
 */
 
/** @file
 *  IP module implementation.
 *  @see arp.h
 *  \todo
 */
 
#include <async.h>
#include <errno.h>
#include <fibril_sync.h>
#include <stdio.h>
#include <string.h>
 
#include <ipc/ipc.h>
#include <ipc/services.h>
 
#include <sys/types.h>
 
#include "../../err.h"
#include "../../messages.h"
#include "../../modules.h"
 
#include "../../include/net_interface.h"
#include "../../include/inet.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"
 
/** Default IP version.
 */
#define DEFAULT_IPV     4
 
/** 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( in_addr_t )
 
/** 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
 
/** Returns the actual IP header length.
 *  @param header The IP packet header. Input parameter.
 */
#define IP_HEADER_LENGTH( header )      (( header )->ihl * 4u )
 
/** Returns the actual IP packet total length.
 *  @param header The IP packet header. Input parameter.
 */
#define IP_TOTAL_LENGTH( header )       ntohs(( header )->total_length )
 
/** Returns the actual IP packet data length.
 *  @param header The IP packet header. Input parameter.
 */
#define IP_HEADER_DATA_LENGTH( header ) ( IP_TOTAL_LENGTH( header ) - IP_HEADER_LENGTH( header ))
 
/** Returns the IP packet header checksum.
 *  @param header The IP packet header. Input parameter.
 */
#define IP_HEADER_CHECKSUM( header )    ( htons( ip_checksum(( uint8_t * )( header ), IP_HEADER_LENGTH( header ))))
 
/** IP header checksum value for computed zero checksum.
 *  Zero is returned as 0xFFFF (not flipped)
 */
#define IP_HEADER_CHECKSUM_ZERO         0xFFFFu
 
/** 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 );
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, 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 );
void ip_create_last_header( ip_header_ref last, 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 );
 
/** 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 );
 
/** 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 0xFFFF if the computed checksum is zero.
 */
uint16_t ip_checksum( uint8_t * data, size_t length );
 
uint16_t ip_checksum( uint8_t * data, size_t 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;
}
 
 
 
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;
    int                 index;
    ip_route_ref        route;
    in_addr_t           gateway;
 
    ip_netif->arp = NULL;
    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;
        }
        ip_netif->routing = configuration[ 9 ].value && ( configuration[ 9 ].value[ 0 ] == 'y' );
        net_free_settings( configuration, data );
    }
    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;
    }
    // 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_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 ){
//  ERROR_DECLARE;
 
/*  measured_string_t   address;
    measured_string_ref translation;
    char *              data;
*/
/*  packet_t        packet;
    in_addr_t       destination;
*/
    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->state = state;
    // TODO state
    printf( "ip - device %d changed state to %d\n\n", device_id, state );
    fibril_rwlock_write_unlock( & ip_globals.netifs_lock );
//  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 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 ){
    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, ( uint8_t ** ) & dest );
    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;
    }
    fibril_rwlock_read_lock( & ip_globals.netifs_lock );
    // device specified?
//  dest.s_addr = ntohl( dest.s_addr );
    if( device_id > 0 ){
        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 )){
        fibril_rwlock_read_unlock( & ip_globals.netifs_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
        fibril_rwlock_read_unlock( & ip_globals.netifs_lock );
        return ip_deliver_local( -1, packet, ( ip_header_ref ) packet_get_data( packet ));
    }
 
    src = ip_netif_addr( netif );
    if( ! src ){
        fibril_rwlock_read_unlock( & ip_globals.netifs_lock );
        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 ));
    }
    fibril_rwlock_read_unlock( & ip_globals.netifs_lock );
    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;
 
    measured_string_t   destination;
    measured_string_ref translation;
    char *              data;
 
    // get destination hardware address
    if( netif->arp ){
        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 ));
        }
        // TODO unreachable
        if( ! translation ) return EINVAL;
        if( ! translation->value ){
            // TODO unreachable
            free( translation );
            free( data );
            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 );
        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 )));
    }
    header->version = 4;
    header->fragment_offset = 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 = length / 8;
            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 = length / 8;
        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;
 
    * 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:
            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_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;
        case NET_IL_MTU_CHANGED:
            return ip_mtu_changed_message( IPC_GET_DEVICE( call ), IPC_GET_MTU( call ));
    }
    return ENOTSUP;
}
 
int ip_packet_size_req( int ip_phone, device_id_t device_id, size_t * addr_len, size_t * prefix, size_t * content, size_t * suffix ){
    ip_netif_ref    netif;
    int             index;
 
    if( !( addr_len && prefix && content && suffix )) return EBADMEM;
    * content = IP_MAX_CONTENT - IP_PREFIX;
    fibril_rwlock_read_lock( & ip_globals.netifs_lock );
    if( device_id < 0 ){
        * addr_len = IP_ADDR;
        * prefix = 0;
        * suffix = 0;
        for( index = ip_netifs_count( & ip_globals.netifs ) - 1; index >= 0; -- index ){
            netif = ip_netifs_get_index( & ip_globals.netifs, index );
            if( netif ){
                if( netif->addr_len > * addr_len ) * addr_len = netif->addr_len;
                if( netif->prefix > * prefix ) * prefix = netif->prefix;
                if( netif->suffix > * suffix ) * suffix = netif->suffix;
            }
        }
        * prefix = * prefix + IP_PREFIX;
        * suffix = * suffix + IP_SUFFIX;
    }else{
        netif = ip_netifs_find( & ip_globals.netifs, device_id );
        if( ! netif ){
            fibril_rwlock_read_unlock( & ip_globals.netifs_lock );
            return ENOENT;
        }
        * addr_len = ( netif->addr_len > IP_ADDR ) ? netif->addr_len : IP_ADDR;
        * prefix = netif->prefix + IP_PREFIX;
        * suffix = netif->suffix + IP_SUFFIX;
    }
    fibril_rwlock_read_unlock( & ip_globals.netifs_lock );
    return EOK;
}
 
int ip_add_route_req( int ip_phone, device_id_t device_id, in_addr_t address, in_addr_t netmask, in_addr_t gateway ){
    ip_route_ref    route;
    ip_netif_ref    netif;
    int             index;
 
    fibril_rwlock_write_lock( & ip_globals.netifs_lock );
    netif = ip_netifs_find( & ip_globals.netifs, device_id );
    if( ! netif ){
        fibril_rwlock_write_unlock( & ip_globals.netifs_lock );
        return ENOENT;
    }
    route = ( ip_route_ref ) malloc( sizeof( ip_route_t ));
    if( ! route ){
        fibril_rwlock_write_unlock( & ip_globals.netifs_lock );
        return ENOMEM;
    }
    route->address.s_addr = address.s_addr;
    route->netmask.s_addr = netmask.s_addr;
    route->gateway.s_addr = gateway.s_addr;
    route->netif = netif;
    index = ip_routes_add( & netif->routes, route );
    if( index < 0 ) free( route );
    fibril_rwlock_write_unlock( & ip_globals.netifs_lock );
    return index;
}
 
ip_route_ref ip_find_route( in_addr_t destination ){
    int             index;
    ip_route_ref    route;
    ip_netif_ref    netif;
 
    // start with the last netif - the newest one
    index = ip_netifs_count( & ip_globals.netifs ) - 1;
    while( index >= 0 ){
        netif = ip_netifs_get_index( & ip_globals.netifs, index );
        if( netif && ( netif->state == NETIF_ACTIVE )){
            route = ip_netif_find_route( netif, destination );
            if( route ) return route;
        }
        -- index;
    }
    return & ip_globals.gateway;
}
 
ip_route_ref ip_netif_find_route( ip_netif_ref netif, in_addr_t destination ){
    int             index;
    ip_route_ref    route;
 
    if( netif ){
        // start with the first one - the direct route
        for( index = 0; index < ip_routes_count( & netif->routes ); ++ index ){
            route = ip_routes_get_index( & netif->routes, index );
            if( route && (( route->address.s_addr & route->netmask.s_addr ) == ( destination.s_addr & route->netmask.s_addr ))){
                return route;
            }
        }
    }
    return NULL;
}
 
int ip_set_gateway_req( int ip_phone, device_id_t device_id, in_addr_t gateway ){
    ip_netif_ref    netif;
 
    fibril_rwlock_write_lock( & ip_globals.netifs_lock );
    netif = ip_netifs_find( & ip_globals.netifs, device_id );
    if( ! netif ){
        fibril_rwlock_write_unlock( & ip_globals.netifs_lock );
        return ENOENT;
    }
    ip_globals.gateway.address.s_addr = 0;
    ip_globals.gateway.netmask.s_addr = 0;
    ip_globals.gateway.gateway.s_addr = gateway.s_addr;
    ip_globals.gateway.netif = netif;
    fibril_rwlock_write_unlock( & ip_globals.netifs_lock );
    return EOK;
}
 
packet_t ip_split_packet( packet_t packet, size_t prefix, size_t content, size_t suffix, 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, ((( size_t ) address_length > addr_len ) ? ( size_t ) address_length : addr_len ));
    if( ! new_packet ) return ENOMEM;
    // allocate as much as originally
    last_header = ( ip_header_ref ) packet_suffix( new_packet, IP_HEADER_LENGTH( header ));
    if( ! last_header ){
        pq_release( ip_globals.net_phone, packet_get_id( new_packet ));
        return ENOMEM;
    }
    ip_create_last_header( last_header, header );
    // trim the unused space
    if( ERROR_OCCURRED( packet_trim( new_packet, 0, IP_HEADER_LENGTH( header ) - IP_HEADER_LENGTH( last_header )))){
        pq_release( ip_globals.net_phone, packet_get_id( new_packet ));
        return ERROR_CODE;
    }
    // biggest multiple of 8 lower than content
    // TODO even fragmentation?
    length = length & ( ~ 0x7 );// ( content / 8 ) * 8
    if( ERROR_OCCURRED( ip_fragment_packet_data( packet, new_packet, header, last_header, (( IP_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;
}
 
void ip_create_last_header( ip_header_ref last, ip_header_ref first ){
    ip_option_ref   option;
    size_t          next;
    size_t          length;
 
    // copy first itself
    memcpy( last, first, sizeof( ip_header_t ));
    length = sizeof( ip_header_t );
    next = sizeof( ip_header_t );
    // process all ip options
    while( next < first->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;
    }
    last->header_checksum = 0;
}
 
int ip_receive_message( 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{
        // only if routing enabled
        if( route->netif->routing ){
            return ip_send_route( packet, route->netif, route, NULL, dest );
        }
        else
        {
            // TODO icmp unreachable?
            return ENOENT;
        }
    }
}
 
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{
        ERROR_PROPAGATE( packet_set_addr( packet, ( uint8_t * ) & header->source_address, ( uint8_t * ) & header->destination_address, IP_ADDR ));
        fibril_rwlock_read_lock( & ip_globals.protos_lock );
        proto = ip_protos_find( & ip_globals.protos, header->protocol );
        if( ! proto ){
            fibril_rwlock_read_unlock( & ip_globals.protos_lock );
            return ENOENT;
        }
        if( proto->received_msg ){
            ERROR_CODE = proto->received_msg( device_id, packet, SERVICE_IP );
        }else{
            ERROR_CODE = tl_received_msg( proto->phone, device_id, packet, proto->service );
        }
        fibril_rwlock_read_unlock( & ip_globals.protos_lock );
        return ERROR_CODE;
    }
}
 
in_addr_t ip_get_destination( ip_header_ref header ){
    in_addr_t   destination;
 
    // TODO search set ipopt route?
    destination.s_addr = header->destination_address; //ntohl( header->destination_address );
    return destination;
}
 
/** @}
 */
 

Rev 4695	Rev 4702
1	/*	1	/*
2	* Copyright (c) 2009 Lukas Mejdrech	2	* Copyright (c) 2009 Lukas Mejdrech
3	* All rights reserved.	3	* All rights reserved.
4	*	4	*
5	* Redistribution and use in source and binary forms, with or without	5	* Redistribution and use in source and binary forms, with or without
6	* modification, are permitted provided that the following conditions	6	* modification, are permitted provided that the following conditions
7	* are met:	7	* are met:
8	*	8	*
9	* - Redistributions of source code must retain the above copyright	9	* - Redistributions of source code must retain the above copyright
10	* notice, this list of conditions and the following disclaimer.	10	* notice, this list of conditions and the following disclaimer.
11	* - Redistributions in binary form must reproduce the above copyright	11	* - Redistributions in binary form must reproduce the above copyright
12	* notice, this list of conditions and the following disclaimer in the	12	* notice, this list of conditions and the following disclaimer in the
13	* documentation and/or other materials provided with the distribution.	13	* documentation and/or other materials provided with the distribution.
14	* - The name of the author may not be used to endorse or promote products	14	* - The name of the author may not be used to endorse or promote products
15	* derived from this software without specific prior written permission.	15	* derived from this software without specific prior written permission.
16	*	16	*
17	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR	17	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES	18	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.	19	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,	20	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT	21	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,	22	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY	23	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT	24	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF	25	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.	26	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27	*/	27	*/
28		28
29	/** @addtogroup ip	29	/** @addtogroup ip
30	* @{	30	* @{
31	*/	31	*/
32		32
33	/** @file	33	/** @file
-		34	* IP module implementation.
-		35	* @see arp.h
-		36	* \todo
34	*/	37	*/
35		38
36	#include <async.h>	39	#include <async.h>
37	#include <errno.h>	40	#include <errno.h>
38	#include <fibril_sync.h>	41	#include <fibril_sync.h>
39	#include <stdio.h>	42	#include <stdio.h>
40	#include <string.h>	43	#include <string.h>
41		44
42	#include <ipc/ipc.h>	45	#include <ipc/ipc.h>
43	#include <ipc/services.h>	46	#include <ipc/services.h>
44		47
45	#include <sys/types.h>	48	#include <sys/types.h>
46		49
47	#include "../../err.h"	50	#include "../../err.h"
48	#include "../../messages.h"	51	#include "../../messages.h"
49	#include "../../modules.h"	52	#include "../../modules.h"
50		53
51	#include "../../include/net_interface.h"	54	#include "../../include/net_interface.h"
52	#include "../../include/inet.h"	55	#include "../../include/inet.h"
53	#include "../../include/socket.h"	56	#include "../../include/socket.h"
54	#include "../../include/byteorder.h"	57	#include "../../include/byteorder.h"
55	#include "../../include/crc.h"	58	#include "../../include/crc.h"
56	#include "../../include/device.h"	59	#include "../../include/device.h"
57	#include "../../include/arp_interface.h"	60	#include "../../include/arp_interface.h"
58	#include "../../include/nil_interface.h"	61	#include "../../include/nil_interface.h"
59	#include "../../include/il_interface.h"	62	#include "../../include/il_interface.h"
60	#include "../../include/ip_client.h"	63	#include "../../include/ip_client.h"
61	#include "../../include/ip_interface.h"	64	#include "../../include/ip_interface.h"
62	#include "../../include/tl_interface.h"	65	#include "../../include/tl_interface.h"
63	#include "../../structures/measured_strings.h"	66	#include "../../structures/measured_strings.h"
64	#include "../../structures/module_map.h"	67	#include "../../structures/module_map.h"
65	#include "../../structures/packet/packet_client.h"	68	#include "../../structures/packet/packet_client.h"
66		69
67	#include "../../nil/nil_messages.h"	70	#include "../../nil/nil_messages.h"
68		71
69	#include "../il_messages.h"	72	#include "../il_messages.h"
70		73
71	#include "ip.h"	74	#include "ip.h"
72	#include "ip_header.h"	75	#include "ip_header.h"
73	#include "ip_messages.h"	76	#include "ip_messages.h"
74	#include "ip_module.h"	77	#include "ip_module.h"
75		78
-		79	/** Default IP version.
-		80	*/
76	#define DEFAULT_IPV 4	81	#define DEFAULT_IPV 4
-		82
-		83	/** Minimum IP packet content.
-		84	*/
77	#define IP_MIN_CONTENT 576	85	#define IP_MIN_CONTENT 576
78		86
-		87	/** ARP module name.
-		88	*/
79	#define ARP_NAME "arp"	89	#define ARP_NAME "arp"
-		90
-		91	/** ARP module filename.
-		92	*/
80	#define ARP_FILENAME "/srv/arp"	93	#define ARP_FILENAME "/srv/arp"
81		94
-		95	/** IP packet address length.
-		96	*/
82	#define IP_ADDR sizeof( in_addr_t )	97	#define IP_ADDR sizeof( in_addr_t )
-		98
-		99	/** IP packet prefix length.
-		100	*/
83	#define IP_PREFIX sizeof( ip_header_t )	101	#define IP_PREFIX sizeof( ip_header_t )
-		102
-		103	/** IP packet suffix length.
-		104	*/
84	#define IP_SUFFIX 0	105	#define IP_SUFFIX 0
-		106
-		107	/** IP packet maximum content length.
-		108	*/
85	#define IP_MAX_CONTENT 65535	109	#define IP_MAX_CONTENT 65535
-		110
-		111	/** Returns the actual IP header length.
-		112	* @param header The IP packet header. Input parameter.
-		113	*/
86	#define IP_HEADER_LENGTH( header ) (( header )->ihl * 4u )	114	#define IP_HEADER_LENGTH( header ) (( header )->ihl * 4u )
-		115
-		116	/** Returns the actual IP packet total length.
-		117	* @param header The IP packet header. Input parameter.
-		118	*/
87	#define IP_TOTAL_LENGTH( header ) ntohs(( header )->total_length )	119	#define IP_TOTAL_LENGTH( header ) ntohs(( header )->total_length )
-		120
-		121	/** Returns the actual IP packet data length.
-		122	* @param header The IP packet header. Input parameter.
-		123	*/
88	#define IP_HEADER_DATA_LENGTH( header ) ( IP_TOTAL_LENGTH( header ) - IP_HEADER_LENGTH( header ))	124	#define IP_HEADER_DATA_LENGTH( header ) ( IP_TOTAL_LENGTH( header ) - IP_HEADER_LENGTH( header ))
-		125
-		126	/** Returns the IP packet header checksum.
-		127	* @param header The IP packet header. Input parameter.
-		128	*/
89	#define IP_HEADER_CHECKSUM( header ) ( htons( ip_checksum(( uint8_t * )( header ), IP_HEADER_LENGTH( header ))))	129	#define IP_HEADER_CHECKSUM( header ) ( htons( ip_checksum(( uint8_t * )( header ), IP_HEADER_LENGTH( header ))))
90		130
-		131	/** IP header checksum value for computed zero checksum.
91	//zero is returned as 0xFFFF (not flipped)	132	* Zero is returned as 0xFFFF (not flipped)
-		133	*/
92	#define IP_HEADER_CHECKSUM_ZERO 0xFFFFu	134	#define IP_HEADER_CHECKSUM_ZERO 0xFFFFu
93		135
-		136	/** IP global data.
-		137	*/
94	ip_globals_t ip_globals;	138	ip_globals_t ip_globals;
95		139
96	DEVICE_MAP_IMPLEMENT( ip_netifs, ip_netif_t )	140	DEVICE_MAP_IMPLEMENT( ip_netifs, ip_netif_t )
97		141
98	INT_MAP_IMPLEMENT( ip_protos, ip_proto_t )	142	INT_MAP_IMPLEMENT( ip_protos, ip_proto_t )
99		143
100	GENERIC_FIELD_IMPLEMENT( ip_routes, ip_route_t )	144	GENERIC_FIELD_IMPLEMENT( ip_routes, ip_route_t )
101		145
-		146	/** Updates the device content length according to the new MTU value.
-		147	* @param device_id The device identifier. Input parameter.
-		148	* @param mtu The new mtu value. Input parameter.
-		149	* @returns EOK on success.
-		150	* @returns ENOENT if device is not found.
-		151	*/
102	int ip_mtu_changed_msg( device_id_t device_id, size_t mtu );	152	int ip_mtu_changed_message( device_id_t device_id, size_t mtu );
-		153
-		154	/** Updates the device state.
-		155	* @param device_id The device identifier. Input parameter.
-		156	* @param state The new state value. Input parameter.
-		157	* @returns EOK on success.
-		158	* @returns ENOENT if device is not found.
-		159	*/
103	int ip_device_state_msg( int il_phone, device_id_t device_id, device_state_t state );	160	int ip_device_state_message( device_id_t device_id, device_state_t state );
-		161
104	int ip_register( int protocol, services_t service, int phone, tl_received_msg_t tl_received_msg );	162	int ip_register( int protocol, services_t service, int phone, tl_received_msg_t tl_received_msg );
-		163
-		164	/** Initializes a new network interface specific data.
-		165	* Connects to the network interface layer module, reads the netif configuration, starts an ARP module if needed and sets the netif routing table.
-		166	* The device identifier and the nil service has to be set.
-		167	* @param ip_netif Network interface specific data. Input/output parameter.
-		168	* @returns EOK on success.
-		169	* @returns ENOTSUP if DHCP is configured.
-		170	* @returns ENOTSUP if IPv6 is configured.
-		171	* @returns EINVAL if any of the addresses is invalid.
-		172	* @returns EINVAL if the used ARP module is not known.
-		173	* @returns ENOMEM if there is not enough memory left.
-		174	* @returns Other error codes as defined for the net_get_device_conf_req() function.
-		175	* @returns Other error codes as defined for the bind_service() function.
-		176	* @returns Other error codes as defined for the specific arp_device_req() function.
-		177	* @returns Other error codes as defined for the nil_packet_size_req() function.
-		178	*/
105	int ip_netif_initialize( ip_netif_ref ip_netif );	179	int ip_netif_initialize( ip_netif_ref ip_netif );
106		180
107	int ip_send_route( packet_t packet, ip_netif_ref netif, ip_route_ref route, in_addr_t * src, in_addr_t dest );	181	int ip_send_route( packet_t packet, ip_netif_ref netif, ip_route_ref route, in_addr_t * src, in_addr_t dest );
108	int ip_prepare_packet( in_addr_t * source, in_addr_t dest, packet_t packet, measured_string_ref destination );	182	int ip_prepare_packet( in_addr_t * source, in_addr_t dest, packet_t packet, measured_string_ref destination );
109		183
110	packet_t ip_split_packet( packet_t packet, size_t prefix, size_t content, size_t suffix, size_t addr_len );	184	packet_t ip_split_packet( packet_t packet, size_t prefix, size_t content, size_t suffix, size_t addr_len );
111	int ip_fragment_packet( packet_t packet, size_t length, size_t prefix, size_t suffix, size_t addr_len );	185	int ip_fragment_packet( packet_t packet, size_t length, size_t prefix, size_t suffix, size_t addr_len );
112	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 );	186	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 );
113	ip_header_ref ip_create_middle_header( packet_t packet, ip_header_ref last );	187	ip_header_ref ip_create_middle_header( packet_t packet, ip_header_ref last );
114	void ip_create_last_header( ip_header_ref last, ip_header_ref first );	188	void ip_create_last_header( ip_header_ref last, ip_header_ref first );
115		189
116	in_addr_t * ip_netif_addr( ip_netif_ref netif );	190	in_addr_t * ip_netif_addr( ip_netif_ref netif );
117	ip_route_ref ip_find_route( in_addr_t destination );	191	ip_route_ref ip_find_route( in_addr_t destination );
118	ip_route_ref ip_netif_find_route( ip_netif_ref netif, in_addr_t destination );	192	ip_route_ref ip_netif_find_route( ip_netif_ref netif, in_addr_t destination );
119		193
-		194	/** Processes the received IP packet.
-		195	* @param device_id The source device identifier. Input parameter.
-		196	* @param packet The received packet. Input/output parameter.
-		197	* @returns EOK on success and the packet is no longer needed.
-		198	* @returns EINVAL if the packet is too small to carry the IP packet.
-		199	* @returns EINVAL if the received address lengths differs from the registered values.
-		200	* @returns ENOENT if the device is not found in the cache.
-		201	* @returns ENOENT if the protocol for the device is not found in the cache.
-		202	* @returns ENOMEM if there is not enough memory left.
-		203	*/
120	int ip_received_msg( device_id_t device_id, packet_t packet );	204	int ip_receive_message( device_id_t device_id, packet_t packet );
-		205
121	int ip_process_packet( device_id_t device_id, packet_t packet );	206	int ip_process_packet( device_id_t device_id, packet_t packet );
122	in_addr_t ip_get_destination( ip_header_ref header );	207	in_addr_t ip_get_destination( ip_header_ref header );
123	int ip_deliver_local( device_id_t device_id, packet_t packet, ip_header_ref header );	208	int ip_deliver_local( device_id_t device_id, packet_t packet, ip_header_ref header );
124		209
125	/** Computes the ip header checksum.	210	/** Computes the ip header checksum.
126	* To compute the checksum of a new packet, the checksum header field must be zero.	211	* To compute the checksum of a new packet, the checksum header field must be zero.
127	* To check the checksum of a received packet, the checksum may be left set.	212	* To check the checksum of a received packet, the checksum may be left set.
128	* The zero (0) value will returned in this case if valid.	213	* The zero (0) value will returned in this case if valid.
129	* @param data The header data. Input parameter.	214	* @param data The header data. Input parameter.
130	* @param length The header length in bytes. Input parameter.	215	* @param length The header length in bytes. Input parameter.
131	* @returns The internet protocol header checksum.	216	* @returns The internet protocol header checksum.
132	* @returns 0xFFFF if the computed checksum is zero.	217	* @returns 0xFFFF if the computed checksum is zero.
133	*/	218	*/
134	uint16_t ip_checksum( uint8_t * data, size_t length );	219	uint16_t ip_checksum( uint8_t * data, size_t length );
135		220
136	uint16_t ip_checksum( uint8_t * data, size_t length ){	221	uint16_t ip_checksum( uint8_t * data, size_t length ){
137	uint16_t checksum;	222	uint16_t checksum;
138		223
139	checksum = compact_checksum(compute_checksum( 0, data, length ));	224	checksum = compact_checksum(compute_checksum( 0, data, length ));
140		225
141	// flip, zero is returned as 0xFFFF (not flipped)	226	// flip, zero is returned as 0xFFFF (not flipped)
142	return ( ~ checksum ) ? ~ checksum : IP_HEADER_CHECKSUM_ZERO;	227	return ( ~ checksum ) ? ~ checksum : IP_HEADER_CHECKSUM_ZERO;
143	}	228	}
144		229
145	/** Initializes the module.	-
146	*/	-
147	int ip_initialize( async_client_conn_t client_connection ){	230	int ip_initialize( async_client_conn_t client_connection ){
148	ERROR_DECLARE;	231	ERROR_DECLARE;
149		232
150	fibril_rwlock_initialize( & ip_globals.lock );	233	fibril_rwlock_initialize( & ip_globals.lock );
151	fibril_rwlock_write_lock( & ip_globals.lock );	234	fibril_rwlock_write_lock( & ip_globals.lock );
152	fibril_rwlock_initialize( & ip_globals.protos_lock );	235	fibril_rwlock_initialize( & ip_globals.protos_lock );
153	fibril_rwlock_initialize( & ip_globals.netifs_lock );	236	fibril_rwlock_initialize( & ip_globals.netifs_lock );
154	ip_globals.packet_counter = 0;	237	ip_globals.packet_counter = 0;
155	ip_globals.gateway.address.s_addr = 0;	238	ip_globals.gateway.address.s_addr = 0;
156	ip_globals.gateway.netmask.s_addr = 0;	239	ip_globals.gateway.netmask.s_addr = 0;
157	ip_globals.gateway.gateway.s_addr = 0;	240	ip_globals.gateway.gateway.s_addr = 0;
158	ip_globals.gateway.netif = NULL;	241	ip_globals.gateway.netif = NULL;
159	ERROR_PROPAGATE( ip_netifs_initialize( & ip_globals.netifs ));	242	ERROR_PROPAGATE( ip_netifs_initialize( & ip_globals.netifs ));
160	ERROR_PROPAGATE( ip_protos_initialize( & ip_globals.protos ));	243	ERROR_PROPAGATE( ip_protos_initialize( & ip_globals.protos ));
161	ip_globals.client_connection = client_connection;	244	ip_globals.client_connection = client_connection;
162	ERROR_PROPAGATE( modules_initialize( & ip_globals.modules ));	245	ERROR_PROPAGATE( modules_initialize( & ip_globals.modules ));
163	ERROR_PROPAGATE( add_module( NULL, & ip_globals.modules, ARP_NAME, ARP_FILENAME, SERVICE_ARP, arp_task_get_id(), arp_connect_module ));	246	ERROR_PROPAGATE( add_module( NULL, & ip_globals.modules, ARP_NAME, ARP_FILENAME, SERVICE_ARP, arp_task_get_id(), arp_connect_module ));
164	fibril_rwlock_write_unlock( & ip_globals.lock );	247	fibril_rwlock_write_unlock( & ip_globals.lock );
165	return EOK;	248	return EOK;
166	}	249	}
167		250
168	int ip_device_req( int il_phone, device_id_t device_id, services_t netif ){	251	int ip_device_req( int il_phone, device_id_t device_id, services_t netif ){
169	ERROR_DECLARE;	252	ERROR_DECLARE;
170		253
171	ip_netif_ref ip_netif;	254	ip_netif_ref ip_netif;
172	ip_route_ref route;	255	ip_route_ref route;
173	int index;	256	int index;
174	char * data;	257	char * data;
175		258
176	ip_netif = ( ip_netif_ref ) malloc( sizeof( ip_netif_t ));	259	ip_netif = ( ip_netif_ref ) malloc( sizeof( ip_netif_t ));
177	if( ! ip_netif ) return ENOMEM;	260	if( ! ip_netif ) return ENOMEM;
178	if( ERROR_OCCURRED( ip_routes_initialize( & ip_netif->routes ))){	261	if( ERROR_OCCURRED( ip_routes_initialize( & ip_netif->routes ))){
179	free( ip_netif );	262	free( ip_netif );
180	return ERROR_CODE;	263	return ERROR_CODE;
181	}	264	}
182	ip_netif->device_id = device_id;	265	ip_netif->device_id = device_id;
183	ip_netif->service = netif;	266	ip_netif->service = netif;
184	ip_netif->state = NETIF_STOPPED;	267	ip_netif->state = NETIF_STOPPED;
185	fibril_rwlock_write_lock( & ip_globals.netifs_lock );	268	fibril_rwlock_write_lock( & ip_globals.netifs_lock );
186	if( ERROR_OCCURRED( ip_netif_initialize( ip_netif ))){	269	if( ERROR_OCCURRED( ip_netif_initialize( ip_netif ))){
187	fibril_rwlock_write_unlock( & ip_globals.netifs_lock );	270	fibril_rwlock_write_unlock( & ip_globals.netifs_lock );
188	ip_routes_destroy( & ip_netif->routes );	271	ip_routes_destroy( & ip_netif->routes );
189	free( ip_netif );	272	free( ip_netif );
190	return ERROR_CODE;	273	return ERROR_CODE;
191	}	274	}
192	if( ip_netif->arp ) ++ ip_netif->arp->usage;	275	if( ip_netif->arp ) ++ ip_netif->arp->usage;
193	// print the settings	276	// print the settings
194	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 );	277	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 );
195	printf( "\tconfiguration\t= %s\n", ip_netif->dhcp ? "dhcp" : "static" );	278	printf( "\tconfiguration\t= %s\n", ip_netif->dhcp ? "dhcp" : "static" );
196	// TODO ipv6 addresses	279	// TODO ipv6 addresses
197	data = ( char * ) malloc( INET_ADDRSTRLEN );	280	data = ( char * ) malloc( INET_ADDRSTRLEN );
198	if( data ){	281	if( data ){
199	for( index = 0; index < ip_routes_count( & ip_netif->routes ); ++ index ){	282	for( index = 0; index < ip_routes_count( & ip_netif->routes ); ++ index ){
200	route = ip_routes_get_index( & ip_netif->routes, index );	283	route = ip_routes_get_index( & ip_netif->routes, index );
201	if( route ){	284	if( route ){
202	printf( "\tRouting %d:\n", index );	285	printf( "\tRouting %d:\n", index );
203	inet_ntop( AF_INET, ( uint8_t * ) & route->address.s_addr, data, INET_ADDRSTRLEN );	286	inet_ntop( AF_INET, ( uint8_t * ) & route->address.s_addr, data, INET_ADDRSTRLEN );
204	printf( "\t\taddress\t= %s\n", data );	287	printf( "\t\taddress\t= %s\n", data );
205	inet_ntop( AF_INET, ( uint8_t * ) & route->netmask.s_addr, data, INET_ADDRSTRLEN );	288	inet_ntop( AF_INET, ( uint8_t * ) & route->netmask.s_addr, data, INET_ADDRSTRLEN );
206	printf( "\t\tnetmask\t= %s\n", data );	289	printf( "\t\tnetmask\t= %s\n", data );
207	inet_ntop( AF_INET, ( uint8_t * ) & route->gateway.s_addr, data, INET_ADDRSTRLEN );	290	inet_ntop( AF_INET, ( uint8_t * ) & route->gateway.s_addr, data, INET_ADDRSTRLEN );
208	printf( "\t\tgateway\t= %s\n", data );	291	printf( "\t\tgateway\t= %s\n", data );
209	}	292	}
210	}	293	}
211	inet_ntop( AF_INET, ( uint8_t * ) & ip_netif->broadcast.s_addr, data, INET_ADDRSTRLEN );	294	inet_ntop( AF_INET, ( uint8_t * ) & ip_netif->broadcast.s_addr, data, INET_ADDRSTRLEN );
212	printf( "\tbroadcast\t= %s\n", data );	295	printf( "\tbroadcast\t= %s\n", data );
213	inet_ntop( AF_INET, ( uint8_t * ) & ip_netif->dns1, data, INET_ADDRSTRLEN );	296	inet_ntop( AF_INET, ( uint8_t * ) & ip_netif->dns1, data, INET_ADDRSTRLEN );
214	printf( "\tdns1\t= %s\n", data );	297	printf( "\tdns1\t= %s\n", data );
215	inet_ntop( AF_INET, ( uint8_t * ) & ip_netif->dns2, data, INET_ADDRSTRLEN );	298	inet_ntop( AF_INET, ( uint8_t * ) & ip_netif->dns2, data, INET_ADDRSTRLEN );
216	printf( "\tdns2\t= %s\n", data );	299	printf( "\tdns2\t= %s\n", data );
217	free( data );	300	free( data );
218	}	301	}
219	fibril_rwlock_write_unlock( & ip_globals.netifs_lock );	302	fibril_rwlock_write_unlock( & ip_globals.netifs_lock );
220	return EOK;	303	return EOK;
221	}	304	}
222		305
223	int ip_netif_initialize( ip_netif_ref ip_netif ){	306	int ip_netif_initialize( ip_netif_ref ip_netif ){
224	ERROR_DECLARE;	307	ERROR_DECLARE;
225		308
226	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 }};	309	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 }};
227	measured_string_ref configuration;	310	measured_string_ref configuration;
228	size_t count = sizeof( names ) / sizeof( measured_string_t );	311	size_t count = sizeof( names ) / sizeof( measured_string_t );
229	char * data;	312	char * data;
230	int index;	313	int index;
231	ip_route_ref route;	314	ip_route_ref route;
232	in_addr_t gateway;	315	in_addr_t gateway;
233		316
234	ip_netif->arp = 0;	317	ip_netif->arp = NULL;
235	route = NULL;	318	route = NULL;
236	configuration = & names[ 0 ];	319	configuration = & names[ 0 ];
237	// get configuration	320	// get configuration
238	ERROR_PROPAGATE( net_get_device_conf_req( ip_globals.net_phone, ip_netif->device_id, & configuration, count, & data ));	321	ERROR_PROPAGATE( net_get_device_conf_req( ip_globals.net_phone, ip_netif->device_id, & configuration, count, & data ));
239	if( configuration ){	322	if( configuration ){
240	if( configuration[ 0 ].value ){	323	if( configuration[ 0 ].value ){
241	ip_netif->ipv = strtol( configuration[ 0 ].value, NULL, 0 );	324	ip_netif->ipv = strtol( configuration[ 0 ].value, NULL, 0 );
242	}else{	325	}else{
243	ip_netif->ipv = DEFAULT_IPV;	326	ip_netif->ipv = DEFAULT_IPV;
244	}	327	}
245	ip_netif->dhcp = ! str_lcmp( configuration[ 1 ].value, "dhcp", configuration[ 1 ].length );	328	ip_netif->dhcp = ! str_lcmp( configuration[ 1 ].value, "dhcp", configuration[ 1 ].length );
246	if( ip_netif->dhcp ){	329	if( ip_netif->dhcp ){
247	// TODO dhcp	330	// TODO dhcp
248	net_free_settings( configuration, data );	331	net_free_settings( configuration, data );
249	return ENOTSUP;	332	return ENOTSUP;
250	}else if( ip_netif->ipv == 4 ){	333	}else if( ip_netif->ipv == 4 ){
251	route = ( ip_route_ref ) malloc( sizeof( ip_route_t ));	334	route = ( ip_route_ref ) malloc( sizeof( ip_route_t ));
252	if( ! route ){	335	if( ! route ){
253	net_free_settings( configuration, data );	336	net_free_settings( configuration, data );
254	return ENOMEM;	337	return ENOMEM;
255	}	338	}
256	route->address.s_addr = 0;	339	route->address.s_addr = 0;
257	route->netmask.s_addr = 0;	340	route->netmask.s_addr = 0;
258	route->gateway.s_addr = 0;	341	route->gateway.s_addr = 0;
259	route->netif = ip_netif;	342	route->netif = ip_netif;
260	index = ip_routes_add( & ip_netif->routes, route );	343	index = ip_routes_add( & ip_netif->routes, route );
261	if( index < 0 ){	344	if( index < 0 ){
262	net_free_settings( configuration, data );	345	net_free_settings( configuration, data );
263	free( route );	346	free( route );
264	return index;	347	return index;
265	}	348	}
266	if( ERROR_OCCURRED( inet_pton( AF_INET, configuration[ 2 ].value, ( uint8_t * ) & route->address.s_addr ))	349	if( ERROR_OCCURRED( inet_pton( AF_INET, configuration[ 2 ].value, ( uint8_t * ) & route->address.s_addr ))
267	\|\| ERROR_OCCURRED( inet_pton( AF_INET, configuration[ 3 ].value, ( uint8_t * ) & route->netmask.s_addr ))	350	\|\| ERROR_OCCURRED( inet_pton( AF_INET, configuration[ 3 ].value, ( uint8_t * ) & route->netmask.s_addr ))
268	\|\| ( inet_pton( AF_INET, configuration[ 4 ].value, ( uint8_t * ) & gateway.s_addr ) == EINVAL )	351	\|\| ( inet_pton( AF_INET, configuration[ 4 ].value, ( uint8_t * ) & gateway.s_addr ) == EINVAL )
269	\|\| ( inet_pton( AF_INET, configuration[ 5 ].value, ( uint8_t * ) & ip_netif->broadcast.s_addr ) == EINVAL )	352	\|\| ( inet_pton( AF_INET, configuration[ 5 ].value, ( uint8_t * ) & ip_netif->broadcast.s_addr ) == EINVAL )
270	\|\| ( inet_pton( AF_INET, configuration[ 6 ].value, ( uint8_t * ) & ip_netif->dns1 ) == EINVAL )	353	\|\| ( inet_pton( AF_INET, configuration[ 6 ].value, ( uint8_t * ) & ip_netif->dns1 ) == EINVAL )
271	\|\| ( inet_pton( AF_INET, configuration[ 7 ].value, ( uint8_t * ) & ip_netif->dns2 ) == EINVAL )){	354	\|\| ( inet_pton( AF_INET, configuration[ 7 ].value, ( uint8_t * ) & ip_netif->dns2 ) == EINVAL )){
272	net_free_settings( configuration, data );	355	net_free_settings( configuration, data );
273	return EINVAL;	356	return EINVAL;
274	}	357	}
275	}else{	358	}else{
276	// TODO ipv6 in separate module	359	// TODO ipv6 in separate module
277	net_free_settings( configuration, data );	360	net_free_settings( configuration, data );
278	return ENOTSUP;	361	return ENOTSUP;
279	}	362	}
280	if( configuration[ 8 ].value ){	363	if( configuration[ 8 ].value ){
281	ip_netif->arp = get_running_module( & ip_globals.modules, configuration[ 8 ].value );	364	ip_netif->arp = get_running_module( & ip_globals.modules, configuration[ 8 ].value );
282	if( ! ip_netif->arp ){	365	if( ! ip_netif->arp ){
283	printf( "Failed to start the arp %s\n", configuration[ 8 ].value );	366	printf( "Failed to start the arp %s\n", configuration[ 8 ].value );
284	net_free_settings( configuration, data );	367	net_free_settings( configuration, data );
285	return EINVAL;	368	return EINVAL;
286	}	369	}
287	}else{	370	}else{
288	ip_netif->arp = NULL;	371	ip_netif->arp = NULL;
289	}	372	}
290	ip_netif->routing = configuration[ 9 ].value && ( configuration[ 9 ].value[ 0 ] == 'y' );	373	ip_netif->routing = configuration[ 9 ].value && ( configuration[ 9 ].value[ 0 ] == 'y' );
291	net_free_settings( configuration, data );	374	net_free_settings( configuration, data );
292	}	375	}
293	ip_netif->phone = bind_service( ip_netif->service, ( ipcarg_t ) ip_netif->device_id, SERVICE_IP, 0, ip_globals.client_connection );	376	ip_netif->phone = bind_service( ip_netif->service, ( ipcarg_t ) ip_netif->device_id, SERVICE_IP, 0, ip_globals.client_connection );
294	if( ip_netif->phone < 0 ){	377	if( ip_netif->phone < 0 ){
295	printf( "Failed to contact the nil service %d\n", ip_netif->service );	378	printf( "Failed to contact the nil service %d\n", ip_netif->service );
296	return ip_netif->phone;	379	return ip_netif->phone;
297	}	380	}
298	// MUST BE AFTER the bind_service up there!	381	// MUST BE AFTER the bind_service up there!
299	if( ip_netif->arp ){	382	if( ip_netif->arp ){
300	if( route ){	383	if( route ){
301	configuration[ 0 ].value = ( char * ) & route->address.s_addr;	384	configuration[ 0 ].value = ( char * ) & route->address.s_addr;
302	configuration[ 0 ].length = CONVERT_SIZE( in_addr_t, char, 1 );	385	configuration[ 0 ].length = CONVERT_SIZE( in_addr_t, char, 1 );
303	ERROR_PROPAGATE( arp_device_req( ip_netif->arp->phone, ip_netif->device_id, SERVICE_IP, ip_netif->service, & configuration[ 0 ] ));	386	ERROR_PROPAGATE( arp_device_req( ip_netif->arp->phone, ip_netif->device_id, SERVICE_IP, ip_netif->service, & configuration[ 0 ] ));
304	}else{	387	}else{
305	ip_netif->arp = 0;	388	ip_netif->arp = 0;
306	}	389	}
307	}	390	}
308	// get packet dimensions	391	// get packet dimensions
309	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 ));	392	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 ));
310	if( ip_netif->content < IP_MIN_CONTENT ){	393	if( ip_netif->content < IP_MIN_CONTENT ){
311	printf( "Maximum transmission unit %d bytes is too small, at least %d bytes are needed\n", ip_netif->content, IP_MIN_CONTENT );	394	printf( "Maximum transmission unit %d bytes is too small, at least %d bytes are needed\n", ip_netif->content, IP_MIN_CONTENT );
312	ip_netif->content = IP_MIN_CONTENT;	395	ip_netif->content = IP_MIN_CONTENT;
313	}	396	}
314	index = ip_netifs_add( & ip_globals.netifs, ip_netif->device_id, ip_netif );	397	index = ip_netifs_add( & ip_globals.netifs, ip_netif->device_id, ip_netif );
315	if( index < 0 ) return index;	398	if( index < 0 ) return index;
316	if( gateway.s_addr ){	399	if( gateway.s_addr ){
317	// the default gateway	400	// the default gateway
318	ip_globals.gateway.address.s_addr = 0;	401	ip_globals.gateway.address.s_addr = 0;
319	ip_globals.gateway.netmask.s_addr = 0;	402	ip_globals.gateway.netmask.s_addr = 0;
320	ip_globals.gateway.gateway.s_addr = gateway.s_addr;	403	ip_globals.gateway.gateway.s_addr = gateway.s_addr;
321	ip_globals.gateway.netif = ip_netif;	404	ip_globals.gateway.netif = ip_netif;
322	}	405	}
323	return EOK;	406	return EOK;
324	}	407	}
325		408
326	int ip_mtu_changed_msg( device_id_t device_id, size_t mtu ){	409	int ip_mtu_changed_message( device_id_t device_id, size_t mtu ){
327	ip_netif_ref netif;	410	ip_netif_ref netif;
328		411
329	fibril_rwlock_write_lock( & ip_globals.netifs_lock );	412	fibril_rwlock_write_lock( & ip_globals.netifs_lock );
330	netif = ip_netifs_find( & ip_globals.netifs, device_id );	413	netif = ip_netifs_find( & ip_globals.netifs, device_id );
331	if( ! netif ){	414	if( ! netif ){
332	fibril_rwlock_write_unlock( & ip_globals.netifs_lock );	415	fibril_rwlock_write_unlock( & ip_globals.netifs_lock );
333	return ENOENT;	416	return ENOENT;
334	}	417	}
335	netif->content = mtu;	418	netif->content = mtu;
336	printf( "ip - device %d changed mtu to %d\n\n", device_id, mtu );	419	printf( "ip - device %d changed mtu to %d\n\n", device_id, mtu );
337	fibril_rwlock_write_unlock( & ip_globals.netifs_lock );	420	fibril_rwlock_write_unlock( & ip_globals.netifs_lock );
338	return EOK;	421	return EOK;
339	}	422	}
340		423
341	int ip_device_state_msg( int il_phone, device_id_t device_id, device_state_t state ){	424	int ip_device_state_message( device_id_t device_id, device_state_t state ){
342	// ERROR_DECLARE;	425	// ERROR_DECLARE;
343		426
344	/* measured_string_t address;	427	/* measured_string_t address;
345	measured_string_ref translation;	428	measured_string_ref translation;
346	char * data;	429	char * data;
347	*/	430	*/
348	/* packet_t packet;	431	/* packet_t packet;
349	in_addr_t destination;	432	in_addr_t destination;
350	*/	433	*/
351	ip_netif_ref netif;	434	ip_netif_ref netif;
352		435
353	fibril_rwlock_write_lock( & ip_globals.netifs_lock );	436	fibril_rwlock_write_lock( & ip_globals.netifs_lock );
354	netif = ip_netifs_find( & ip_globals.netifs, device_id );	437	netif = ip_netifs_find( & ip_globals.netifs, device_id );
355	if( ! netif ){	438	if( ! netif ){
356	fibril_rwlock_write_unlock( & ip_globals.netifs_lock );	439	fibril_rwlock_write_unlock( & ip_globals.netifs_lock );
357	return ENOENT;	440	return ENOENT;
358	}	441	}
359	netif->state = state;	442	netif->state = state;
360	// TODO state	443	// TODO state
361	printf( "ip - device %d changed state to %d\n\n", device_id, state );	444	printf( "ip - device %d changed state to %d\n\n", device_id, state );
362	fibril_rwlock_write_unlock( & ip_globals.netifs_lock );	445	fibril_rwlock_write_unlock( & ip_globals.netifs_lock );
363	// if( netif->arp ){	446	// if( netif->arp ){
364	/* address.value = ( char * ) & ip_globals.gateway.gateway.s_addr;	447	/* address.value = ( char * ) & ip_globals.gateway.gateway.s_addr;
365	address.length = CONVERT_SIZE( ip_globals.gateway.gateway.s_addr, char, 1 );	448	address.length = CONVERT_SIZE( ip_globals.gateway.gateway.s_addr, char, 1 );
366	if( ERROR_OCCURRED( arp_translate_req( netif->arp->phone, netif->device_id, SERVICE_IP, & address, & translation, & data ))){	449	if( ERROR_OCCURRED( arp_translate_req( netif->arp->phone, netif->device_id, SERVICE_IP, & address, & translation, & data ))){
367	ERROR_PROPAGATE( arp_translate_req( netif->arp->phone, netif->device_id, SERVICE_IP, & address, & translation, & data ));	450	ERROR_PROPAGATE( arp_translate_req( netif->arp->phone, netif->device_id, SERVICE_IP, & address, & translation, & data ));
368	}	451	}
369	printf( "\tgateway translated to\t= %X:%X:%X:%X:%X:%X\n", data[ 0 ], data[ 1 ], data[ 2 ], data[ 3 ], data[ 4 ], data[ 5 ] );	452	printf( "\tgateway translated to\t= %X:%X:%X:%X:%X:%X\n", data[ 0 ], data[ 1 ], data[ 2 ], data[ 3 ], data[ 4 ], data[ 5 ] );
370	free( translation );	453	free( translation );
371	free( data );	454	free( data );
372	address.value = ( char * ) & ip_globals.gateway.gateway.s_addr;	455	address.value = ( char * ) & ip_globals.gateway.gateway.s_addr;
373	address.length = CONVERT_SIZE( ip_globals.gateway.gateway.s_addr, char, 1 );	456	address.length = CONVERT_SIZE( ip_globals.gateway.gateway.s_addr, char, 1 );
374	if( ERROR_OCCURRED( arp_translate_req( netif->arp->phone, netif->device_id, SERVICE_IP, & address, & translation, & data ))){	457	if( ERROR_OCCURRED( arp_translate_req( netif->arp->phone, netif->device_id, SERVICE_IP, & address, & translation, & data ))){
375	sleep( 2 );	458	sleep( 2 );
376	ERROR_PROPAGATE( arp_translate_req( netif->arp->phone, netif->device_id, SERVICE_IP, & address, & translation, & data ));	459	ERROR_PROPAGATE( arp_translate_req( netif->arp->phone, netif->device_id, SERVICE_IP, & address, & translation, & data ));
377	}	460	}
378	printf( "\tgateway translated to\t= %X:%X:%X:%X:%X:%X\n", data[ 0 ], data[ 1 ], data[ 2 ], data[ 3 ], data[ 4 ], data[ 5 ] );	461	printf( "\tgateway translated to\t= %X:%X:%X:%X:%X:%X\n", data[ 0 ], data[ 1 ], data[ 2 ], data[ 3 ], data[ 4 ], data[ 5 ] );
379	free( translation );	462	free( translation );
380	free( data );	463	free( data );
381	// printf( "IP - testing to send packet:\n" );	464	// printf( "IP - testing to send packet:\n" );
382	ERROR_PROPAGATE( inet_pton( AF_INET, "90.182.101.18", ( uint8_t * ) & destination.s_addr ));	465	ERROR_PROPAGATE( inet_pton( AF_INET, "90.182.101.18", ( uint8_t * ) & destination.s_addr ));
383	packet = packet_get_4( ip_globals.net_phone, 30, netif->addr_len, netif->prefix + sizeof( ip_header_t ), netif->suffix );	466	packet = packet_get_4( ip_globals.net_phone, 30, netif->addr_len, netif->prefix + sizeof( ip_header_t ), netif->suffix );
384	if( ! packet ) return ENOMEM;	467	if( ! packet ) return ENOMEM;
385	pq_release( ip_globals.net_phone, packet_get_id( packet ));	468	pq_release( ip_globals.net_phone, packet_get_id( packet ));
386	packet = packet_get_4( ip_globals.net_phone, 30, netif->addr_len, netif->prefix + sizeof( ip_header_t ), netif->suffix );	469	packet = packet_get_4( ip_globals.net_phone, 30, netif->addr_len, netif->prefix + sizeof( ip_header_t ), netif->suffix );
387	if( ! packet ) return ENOMEM;	470	if( ! packet ) return ENOMEM;
388	pq_release( ip_globals.net_phone, packet_get_id( packet ));	471	pq_release( ip_globals.net_phone, packet_get_id( packet ));
389	packet = packet_get_4( ip_globals.net_phone, 30, netif->addr_len, netif->prefix + sizeof( ip_header_t ), netif->suffix );	472	packet = packet_get_4( ip_globals.net_phone, 30, netif->addr_len, netif->prefix + sizeof( ip_header_t ), netif->suffix );
390	if( ! packet ) return ENOMEM;	473	if( ! packet ) return ENOMEM;
391	pq_release( ip_globals.net_phone, packet_get_id( packet ));	474	pq_release( ip_globals.net_phone, packet_get_id( packet ));
392	packet = packet_get_4( ip_globals.net_phone, 1500, netif->addr_len, netif->prefix + sizeof( ip_header_t ), netif->suffix );	475	packet = packet_get_4( ip_globals.net_phone, 1500, netif->addr_len, netif->prefix + sizeof( ip_header_t ), netif->suffix );
393	if( ! packet ) return ENOMEM;	476	if( ! packet ) return ENOMEM;
394	// try this long version	477	// try this long version
395	// 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 ))	478	// 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 ))
396	if( ERROR_OCCURRED( packet_copy_data( packet, "Hi, this is IP", 14 ))	479	if( ERROR_OCCURRED( packet_copy_data( packet, "Hi, this is IP", 14 ))
397	\|\| ERROR_OCCURRED( packet_set_addr( packet, NULL, ( uint8_t * ) & destination.s_addr, 4 ))	480	\|\| ERROR_OCCURRED( packet_set_addr( packet, NULL, ( uint8_t * ) & destination.s_addr, 4 ))
398	\|\| ERROR_OCCURRED( ip_client_prepare_packet( packet, 0, 0, 0, 0, 0 ))){	481	\|\| ERROR_OCCURRED( ip_client_prepare_packet( packet, 0, 0, 0, 0, 0 ))){
399	pq_release( ip_globals.net_phone, packet_get_id( packet ));	482	pq_release( ip_globals.net_phone, packet_get_id( packet ));
400	}	483	}
401	ERROR_CODE = ip_send_msg( 0, 0, packet, SERVICE_IP );	484	ERROR_CODE = ip_send_msg( 0, 0, packet, SERVICE_IP );
402	printf( "send returned %d\n", ERROR_CODE );	485	printf( "send returned %d\n", ERROR_CODE );
403	}	486	}
404	*/ return EOK;	487	*/ return EOK;
405	}	488	}
406		489
407	int ip_connect_module( services_t service ){	490	int ip_connect_module( services_t service ){
408	return EOK;	491	return EOK;
409	}	492	}
410		493
411	int ip_bind_service( services_t service, int protocol, services_t me, async_client_conn_t receiver, tl_received_msg_t received_msg ){	494	int ip_bind_service( services_t service, int protocol, services_t me, async_client_conn_t receiver, tl_received_msg_t received_msg ){
412	return ip_register( protocol, me, 0, received_msg );	495	return ip_register( protocol, me, 0, received_msg );
413	}	496	}
414		497
415	int ip_register( int protocol, services_t service, int phone, tl_received_msg_t received_msg ){	498	int ip_register( int protocol, services_t service, int phone, tl_received_msg_t received_msg ){

Subversion Repositories HelenOS

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