Changeset aadf01e in mainline for uspace/srv/net/il

Timestamp:

2010-03-07T15:13:28Z (16 years ago)

Author:

Lukas Mejdrech <lukasmejdrech@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

936835e

Parents:

aa85487

Message:

Coding style (no functional change)

Location:

uspace/srv/net/il

Files:

• arp/arp.c (modified) (9 diffs)
• arp/arp.h (modified) (6 diffs)
• arp/arp_header.h (modified) (1 diff)
• arp/arp_messages.h (modified) (1 diff)
• arp/arp_module.c (modified) (5 diffs)
• arp/arp_module.h (modified) (2 diffs)
• arp/arp_remote.c (modified) (1 diff)
• il_messages.h (modified) (1 diff)
• ip/ip.c (modified) (44 diffs)
• ip/ip.h (modified) (8 diffs)
• ip/ip_client.c (modified) (2 diffs)
• ip/ip_header.h (modified) (8 diffs)
• ip/ip_messages.h (modified) (1 diff)
• ip/ip_module.c (modified) (5 diffs)
• ip/ip_module.h (modified) (2 diffs)
• ip/ip_remote.c (modified) (1 diff)

uspace/srv/net/il/arp/arp.c

@@ -81 +81 @@
  *  @returns ENOMEM if there is not enough memory left.
  */
-int     arp_proto_create( arp_proto_ref * proto, services_t service, measured_string_ref address );
+int arp_proto_create(arp_proto_ref * proto, services_t service, measured_string_ref address);
 
 /** Clears the device specific data.
  *  @param[in] device The device specific data.
  */
-void    arp_clear_device( arp_device_ref device );
+void arp_clear_device(arp_device_ref device);
 
 /** @name Message processing functions
@@ -103 +103 @@
  *  @returns Other error codes as defined for the measured_strings_return() function.
  */
-int     arp_device_message( device_id_t device_id, services_t service, services_t protocol, measured_string_ref address );
+int arp_device_message(device_id_t device_id, services_t service, services_t protocol, measured_string_ref address);
 
 /** Returns the hardware address for the given protocol address.
@@ -116 +116 @@
  *  @returns NULL if the hardware address is not found in the cache.
  */
-measured_string_ref     arp_translate_message( device_id_t device_id, services_t protocol, measured_string_ref target );
+measured_string_ref arp_translate_message(device_id_t device_id, services_t protocol, measured_string_ref target);
 
 /** Processes the received ARP packet.
@@ -131 +131 @@
  *  @returns ENOMEM if there is not enough memory left.
  */
-int     arp_receive_message( device_id_t device_id, packet_t packet );
+int arp_receive_message(device_id_t device_id, packet_t packet);
 
 /** Updates the device content length according to the new MTU value.
@@ -139 +139 @@
  *  @returns EOK on success.
  */
-int     arp_mtu_changed_message( device_id_t device_id, size_t mtu );
+int arp_mtu_changed_message(device_id_t device_id, size_t mtu);
 
 /*@}*/
 
-DEVICE_MAP_IMPLEMENT( arp_cache, arp_device_t )
-
-INT_MAP_IMPLEMENT( arp_protos, arp_proto_t )
-
-GENERIC_CHAR_MAP_IMPLEMENT( arp_addr, measured_string_t )
-
-task_id_t arp_task_get_id( void ){
+DEVICE_MAP_IMPLEMENT(arp_cache, arp_device_t)
+
+INT_MAP_IMPLEMENT(arp_protos, arp_proto_t)
+
+GENERIC_CHAR_MAP_IMPLEMENT(arp_addr, measured_string_t)
+
+task_id_t arp_task_get_id(void){
         return task_get_id();
 }
 
-int arp_clear_device_req( int arp_phone, device_id_t device_id ){
-        arp_device_ref  device;
-
-        fibril_rwlock_write_lock( & arp_globals.lock );
-        device = arp_cache_find( & arp_globals.cache, device_id );
-        if( ! device ){
-                fibril_rwlock_write_unlock( & arp_globals.lock );
+int arp_clear_device_req(int arp_phone, device_id_t device_id){
+        arp_device_ref device;
+
+        fibril_rwlock_write_lock(&arp_globals.lock);
+        device = arp_cache_find(&arp_globals.cache, device_id);
+        if(! device){
+                fibril_rwlock_write_unlock(&arp_globals.lock);
                 return ENOENT;
         }
-        arp_clear_device( device );
-        printf( "Device %d cleared\n", device_id );
-        fibril_rwlock_write_unlock( & arp_globals.lock );
-        return EOK;
-}
-
-int arp_clear_address_req( int arp_phone, device_id_t device_id, services_t protocol, measured_string_ref address ){
-        arp_device_ref  device;
-        arp_proto_ref   proto;
-
-        fibril_rwlock_write_lock( & arp_globals.lock );
-        device = arp_cache_find( & arp_globals.cache, device_id );
-        if( ! device ){
-                fibril_rwlock_write_unlock( & arp_globals.lock );
+        arp_clear_device(device);
+        printf("Device %d cleared\n", device_id);
+        fibril_rwlock_write_unlock(&arp_globals.lock);
+        return EOK;
+}
+
+int arp_clear_address_req(int arp_phone, device_id_t device_id, services_t protocol, measured_string_ref address){
+        arp_device_ref device;
+        arp_proto_ref proto;
+
+        fibril_rwlock_write_lock(&arp_globals.lock);
+        device = arp_cache_find(&arp_globals.cache, device_id);
+        if(! device){
+                fibril_rwlock_write_unlock(&arp_globals.lock);
                 return ENOENT;
         }
-        proto = arp_protos_find( & device->protos, protocol );
-        if( ! proto ){
-                fibril_rwlock_write_unlock( & arp_globals.lock );
+        proto = arp_protos_find(&device->protos, protocol);
+        if(! proto){
+                fibril_rwlock_write_unlock(&arp_globals.lock);
                 return ENOENT;
         }
-        arp_addr_exclude( & proto->addresses, address->value, address->length );
-        fibril_rwlock_write_unlock( & arp_globals.lock );
-        return EOK;
-}
-
-int arp_clean_cache_req( int arp_phone ){
-        int                             count;
-        arp_device_ref  device;
-
-        fibril_rwlock_write_lock( & arp_globals.lock );
-        for( count = arp_cache_count( & arp_globals.cache ) - 1; count >= 0; -- count ){
-                device = arp_cache_get_index( & arp_globals.cache, count );
-                if( device ){
-                        arp_clear_device( device );
-                        if( device->addr_data ) free( device->addr_data );
-                        if( device->broadcast_data ) free( device->broadcast_data );
-                }
-        }
-        arp_cache_clear( & arp_globals.cache );
-        fibril_rwlock_write_unlock( & arp_globals.lock );
-        printf( "Cache cleaned\n" );
-        return EOK;
-}
-
-int arp_device_req( int arp_phone, device_id_t device_id, services_t protocol, services_t netif, measured_string_ref address ){
+        arp_addr_exclude(&proto->addresses, address->value, address->length);
+        fibril_rwlock_write_unlock(&arp_globals.lock);
+        return EOK;
+}
+
+int arp_clean_cache_req(int arp_phone){
+        int count;
+        arp_device_ref device;
+
+        fibril_rwlock_write_lock(&arp_globals.lock);
+        for(count = arp_cache_count(&arp_globals.cache) - 1; count >= 0; -- count){
+                device = arp_cache_get_index(&arp_globals.cache, count);
+                if(device){
+                        arp_clear_device(device);
+                        if(device->addr_data){
+                                free(device->addr_data);
+                        }
+                        if(device->broadcast_data){
+                                free(device->broadcast_data);
+                        }
+                }
+        }
+        arp_cache_clear(&arp_globals.cache);
+        fibril_rwlock_write_unlock(&arp_globals.lock);
+        printf("Cache cleaned\n");
+        return EOK;
+}
+
+int arp_device_req(int arp_phone, device_id_t device_id, services_t protocol, services_t netif, measured_string_ref address){
         ERROR_DECLARE;
 
@@ -213 +217 @@
 
         // copy the given address for exclusive use
-        tmp = measured_string_copy( address );
-        if( ERROR_OCCURRED( arp_device_message( device_id, netif, protocol, tmp ))){
-                free( tmp->value );
-                free( tmp );
+        tmp = measured_string_copy(address);
+        if(ERROR_OCCURRED(arp_device_message(device_id, netif, protocol, tmp))){
+                free(tmp->value);
+                free(tmp);
         }
         return ERROR_CODE;
 }
 
-int arp_translate_req( int arp_phone, device_id_t device_id, services_t protocol, measured_string_ref address, measured_string_ref * translation, char ** data ){
-        measured_string_ref     tmp;
-
-        fibril_rwlock_read_lock( & arp_globals.lock );
-        tmp = arp_translate_message( device_id, protocol, address );
-        if( tmp ){
-                * translation = measured_string_copy( tmp );
-                fibril_rwlock_read_unlock( & arp_globals.lock );
-                if( * translation ){
-                        * data = ( ** translation ).value;
+int arp_translate_req(int arp_phone, device_id_t device_id, services_t protocol, measured_string_ref address, measured_string_ref * translation, char ** data){
+        measured_string_ref tmp;
+
+        fibril_rwlock_read_lock(&arp_globals.lock);
+        tmp = arp_translate_message(device_id, protocol, address);
+        if(tmp){
+                *translation = measured_string_copy(tmp);
+                fibril_rwlock_read_unlock(&arp_globals.lock);
+                if(*translation){
+                        *data = (** translation).value;
                         return EOK;
                 }else{
@@ -236 +240 @@
                 }
         }else{
-                fibril_rwlock_read_unlock( & arp_globals.lock );
+                fibril_rwlock_read_unlock(&arp_globals.lock);
                 return ENOENT;
         }
 }
 
-int arp_initialize( async_client_conn_t client_connection ){
+int arp_initialize(async_client_conn_t client_connection){
         ERROR_DECLARE;
 
-        fibril_rwlock_initialize( & arp_globals.lock );
-        fibril_rwlock_write_lock( & arp_globals.lock );
+        fibril_rwlock_initialize(&arp_globals.lock);
+        fibril_rwlock_write_lock(&arp_globals.lock);
         arp_globals.client_connection = client_connection;
-        ERROR_PROPAGATE( arp_cache_initialize( & arp_globals.cache ));
-        fibril_rwlock_write_unlock( & arp_globals.lock );
-        return EOK;
-}
-
-int arp_proto_create( arp_proto_ref * proto, services_t service, measured_string_ref address ){
+        ERROR_PROPAGATE(arp_cache_initialize(&arp_globals.cache));
+        fibril_rwlock_write_unlock(&arp_globals.lock);
+        return EOK;
+}
+
+int arp_proto_create(arp_proto_ref * proto, services_t service, measured_string_ref address){
         ERROR_DECLARE;
 
-        * proto = ( arp_proto_ref ) malloc( sizeof( arp_proto_t ));
-        if( !( * proto )) return ENOMEM;
-        ( ** proto ).service = service;
-        ( ** proto ).addr = address;
-        ( ** proto ).addr_data = address->value;
-        if( ERROR_OCCURRED( arp_addr_initialize( &( ** proto).addresses ))){
-                free( * proto );
+        *proto = (arp_proto_ref) malloc(sizeof(arp_proto_t));
+        if(!(*proto)){
+                return ENOMEM;
+        }
+        (** proto).service = service;
+        (** proto).addr = address;
+        (** proto).addr_data = address->value;
+        if(ERROR_OCCURRED(arp_addr_initialize(&(** proto).addresses))){
+                free(*proto);
                 return ERROR_CODE;
         }
@@ -267 +273 @@
 }
 
-int arp_device_message( device_id_t device_id, services_t service, services_t protocol, measured_string_ref address ){
+int arp_device_message(device_id_t device_id, services_t service, services_t protocol, measured_string_ref address){
         ERROR_DECLARE;
 
-        arp_device_ref  device;
-        arp_proto_ref   proto;
-        int                             index;
-        hw_type_t               hardware;
-
-        fibril_rwlock_write_lock( & arp_globals.lock );
+        arp_device_ref device;
+        arp_proto_ref proto;
+        int index;
+        hw_type_t hardware;
+
+        fibril_rwlock_write_lock(&arp_globals.lock);
         // an existing device?
-        device = arp_cache_find( & arp_globals.cache, device_id );
-        if( device ){
-                if( device->service != service ){
-                        printf( "Device %d already exists\n", device->device_id );
-                        fibril_rwlock_write_unlock( & arp_globals.lock );
+        device = arp_cache_find(&arp_globals.cache, device_id);
+        if(device){
+                if(device->service != service){
+                        printf("Device %d already exists\n", device->device_id);
+                        fibril_rwlock_write_unlock(&arp_globals.lock);
                         return EEXIST;
                 }
-                proto = arp_protos_find( & device->protos, protocol );
-                if( proto ){
-                        free( proto->addr );
-                        free( proto->addr_data );
+                proto = arp_protos_find(&device->protos, protocol);
+                if(proto){
+                        free(proto->addr);
+                        free(proto->addr_data);
                         proto->addr = address;
                         proto->addr_data = address->value;
                 }else{
-                        if( ERROR_OCCURRED( arp_proto_create( & proto, protocol, address ))){
-                                fibril_rwlock_write_unlock( & arp_globals.lock );
+                        if(ERROR_OCCURRED(arp_proto_create(&proto, protocol, address))){
+                                fibril_rwlock_write_unlock(&arp_globals.lock);
                                 return ERROR_CODE;
                         }
-                        index = arp_protos_add( & device->protos, proto->service, proto );
-                        if( index < 0 ){
-                                fibril_rwlock_write_unlock( & arp_globals.lock );
-                                free( proto );
+                        index = arp_protos_add(&device->protos, proto->service, proto);
+                        if(index < 0){
+                                fibril_rwlock_write_unlock(&arp_globals.lock);
+                                free(proto);
                                 return index;
                         }
-                        printf( "New protocol added:\n\tdevice id\t= %d\n\tproto\t= %d", device_id, protocol );
+                        printf("New protocol added:\n\tdevice id\t= %d\n\tproto\t= %d", device_id, protocol);
                 }
         }else{
-                hardware = hardware_map( service );
-                if( ! hardware ) return ENOENT;
+                hardware = hardware_map(service);
+                if(! hardware){
+                        return ENOENT;
+                }
                 // create a new device
-                device = ( arp_device_ref ) malloc( sizeof( arp_device_t ));
-                if( ! device ){
-                        fibril_rwlock_write_unlock( & arp_globals.lock );
+                device = (arp_device_ref) malloc(sizeof(arp_device_t));
+                if(! device){
+                        fibril_rwlock_write_unlock(&arp_globals.lock);
                         return ENOMEM;
                 }
                 device->hardware = hardware;
                 device->device_id = device_id;
-                if( ERROR_OCCURRED( arp_protos_initialize( & device->protos ))
-                || ERROR_OCCURRED( arp_proto_create( & proto, protocol, address ))){
-                        fibril_rwlock_write_unlock( & arp_globals.lock );
-                        free( device );
-                        return ERROR_CODE;
-                }
-                index = arp_protos_add( & device->protos, proto->service, proto );
-                if( index < 0 ){
-                        fibril_rwlock_write_unlock( & arp_globals.lock );
-                        arp_protos_destroy( & device->protos );
-                        free( device );
+                if(ERROR_OCCURRED(arp_protos_initialize(&device->protos))
+                        || ERROR_OCCURRED(arp_proto_create(&proto, protocol, address))){
+                        fibril_rwlock_write_unlock(&arp_globals.lock);
+                        free(device);
+                        return ERROR_CODE;
+                }
+                index = arp_protos_add(&device->protos, proto->service, proto);
+                if(index < 0){
+                        fibril_rwlock_write_unlock(&arp_globals.lock);
+                        arp_protos_destroy(&device->protos);
+                        free(device);
                         return index;
                 }
                 device->service = service;
                 // bind the new one
-                device->phone = nil_bind_service( device->service, ( ipcarg_t ) device->device_id, SERVICE_ARP, arp_globals.client_connection );
-                if( device->phone < 0 ){
-                        fibril_rwlock_write_unlock( & arp_globals.lock );
-                        arp_protos_destroy( & device->protos );
-                        free( device );
+                device->phone = nil_bind_service(device->service, (ipcarg_t) device->device_id, SERVICE_ARP, arp_globals.client_connection);
+                if(device->phone < 0){
+                        fibril_rwlock_write_unlock(&arp_globals.lock);
+                        arp_protos_destroy(&device->protos);
+                        free(device);
                         return EREFUSED;
                 }
                 // get packet dimensions
-                if( ERROR_OCCURRED( nil_packet_size_req( device->phone, device_id, & device->packet_dimension ))){
-                        fibril_rwlock_write_unlock( & arp_globals.lock );
-                        arp_protos_destroy( & device->protos );
-                        free( device );
+                if(ERROR_OCCURRED(nil_packet_size_req(device->phone, device_id, &device->packet_dimension))){
+                        fibril_rwlock_write_unlock(&arp_globals.lock);
+                        arp_protos_destroy(&device->protos);
+                        free(device);
                         return ERROR_CODE;
                 }
                 // get hardware address
-                if( ERROR_OCCURRED( nil_get_addr_req( device->phone, device_id, & device->addr, & device->addr_data ))){
-                        fibril_rwlock_write_unlock( & arp_globals.lock );
-                        arp_protos_destroy( & device->protos );
-                        free( device );
+                if(ERROR_OCCURRED(nil_get_addr_req(device->phone, device_id, &device->addr, &device->addr_data))){
+                        fibril_rwlock_write_unlock(&arp_globals.lock);
+                        arp_protos_destroy(&device->protos);
+                        free(device);
                         return ERROR_CODE;
                 }
                 // get broadcast address
-                if( ERROR_OCCURRED( nil_get_broadcast_addr_req( device->phone, device_id, & device->broadcast_addr, & device->broadcast_data ))){
-                        fibril_rwlock_write_unlock( & arp_globals.lock );
-                        free( device->addr );
-                        free( device->addr_data );
-                        arp_protos_destroy( & device->protos );
-                        free( device );
-                        return ERROR_CODE;
-                }
-                if( ERROR_OCCURRED( arp_cache_add( & arp_globals.cache, device->device_id, device ))){
-                        fibril_rwlock_write_unlock( & arp_globals.lock );
-                        free( device->addr );
-                        free( device->addr_data );
-                        free( device->broadcast_addr );
-                        free( device->broadcast_data );
-                        arp_protos_destroy( & device->protos );
-                        free( device );
-                        return ERROR_CODE;
-                }
-                printf( "New device registered:\n\tid\t= %d\n\ttype\t= 0x%x\n\tservice\t= %d\n\tproto\t= %d\n", device->device_id, device->hardware, device->service, protocol );
-        }
-        fibril_rwlock_write_unlock( & arp_globals.lock );
-        return EOK;
-}
-
-measured_string_ref arp_translate_message( device_id_t device_id, services_t protocol, measured_string_ref target ){
-        arp_device_ref          device;
-        arp_proto_ref           proto;
-        measured_string_ref     addr;
-        size_t                          length;
-        packet_t                        packet;
-        arp_header_ref          header;
-
-        if( ! target ) return NULL;
-        device = arp_cache_find( & arp_globals.cache, device_id );
-        if( ! device ) return NULL;
-        proto = arp_protos_find( & device->protos, protocol );
-        if(( ! proto ) || ( proto->addr->length != target->length )) return NULL;
-        addr = arp_addr_find( & proto->addresses, target->value, target->length );
-        if( addr ) return addr;
-        // ARP packet content size = header + ( address + translation ) * 2
-        length = 8 + ( CONVERT_SIZE( char, uint8_t, proto->addr->length ) + CONVERT_SIZE( char, uint8_t, device->addr->length )) * 2;
-        if( length > device->packet_dimension.content ) return NULL;
-        packet = packet_get_4( arp_globals.net_phone, device->packet_dimension.addr_len, device->packet_dimension.prefix, length, device->packet_dimension.suffix );
-        if( ! packet ) return NULL;
-        header = ( arp_header_ref ) packet_suffix( packet, length );
-        if( ! header ){
-                pq_release( arp_globals.net_phone, packet_get_id( packet ));
+                if(ERROR_OCCURRED(nil_get_broadcast_addr_req(device->phone, device_id, &device->broadcast_addr, &device->broadcast_data))){
+                        fibril_rwlock_write_unlock(&arp_globals.lock);
+                        free(device->addr);
+                        free(device->addr_data);
+                        arp_protos_destroy(&device->protos);
+                        free(device);
+                        return ERROR_CODE;
+                }
+                if(ERROR_OCCURRED(arp_cache_add(&arp_globals.cache, device->device_id, device))){
+                        fibril_rwlock_write_unlock(&arp_globals.lock);
+                        free(device->addr);
+                        free(device->addr_data);
+                        free(device->broadcast_addr);
+                        free(device->broadcast_data);
+                        arp_protos_destroy(&device->protos);
+                        free(device);
+                        return ERROR_CODE;
+                }
+                printf("New device registered:\n\tid\t= %d\n\ttype\t= 0x%x\n\tservice\t= %d\n\tproto\t= %d\n", device->device_id, device->hardware, device->service, protocol);
+        }
+        fibril_rwlock_write_unlock(&arp_globals.lock);
+        return EOK;
+}
+
+measured_string_ref arp_translate_message(device_id_t device_id, services_t protocol, measured_string_ref target){
+        arp_device_ref device;
+        arp_proto_ref proto;
+        measured_string_ref addr;
+        size_t length;
+        packet_t packet;
+        arp_header_ref header;
+
+        if(! target){
                 return NULL;
         }
-        header->hardware = htons( device->hardware );
-        header->hardware_length = ( uint8_t ) device->addr->length;
-        header->protocol = htons( protocol_map( device->service, protocol ));
-        header->protocol_length = ( uint8_t ) proto->addr->length;
-        header->operation = htons( ARPOP_REQUEST );
-        length = sizeof( arp_header_t );
-        memcpy((( uint8_t * ) header ) + length, device->addr->value, device->addr->length );
+        device = arp_cache_find(&arp_globals.cache, device_id);
+        if(! device){
+                return NULL;
+        }
+        proto = arp_protos_find(&device->protos, protocol);
+        if((! proto) || (proto->addr->length != target->length)){
+                return NULL;
+        }
+        addr = arp_addr_find(&proto->addresses, target->value, target->length);
+        if(addr){
+                return addr;
+        }
+        // ARP packet content size = header + (address + translation) * 2
+        length = 8 + (CONVERT_SIZE(char, uint8_t, proto->addr->length) + CONVERT_SIZE(char, uint8_t, device->addr->length)) * 2;
+        if(length > device->packet_dimension.content){
+                return NULL;
+        }
+        packet = packet_get_4(arp_globals.net_phone, device->packet_dimension.addr_len, device->packet_dimension.prefix, length, device->packet_dimension.suffix);
+        if(! packet){
+                return NULL;
+        }
+        header = (arp_header_ref) packet_suffix(packet, length);
+        if(! header){
+                pq_release(arp_globals.net_phone, packet_get_id(packet));
+                return NULL;
+        }
+        header->hardware = htons(device->hardware);
+        header->hardware_length = (uint8_t) device->addr->length;
+        header->protocol = htons(protocol_map(device->service, protocol));
+        header->protocol_length = (uint8_t) proto->addr->length;
+        header->operation = htons(ARPOP_REQUEST);
+        length = sizeof(arp_header_t);
+        memcpy(((uint8_t *) header) + length, device->addr->value, device->addr->length);
         length += device->addr->length;
-        memcpy((( uint8_t * ) header ) + length, proto->addr->value, proto->addr->length );
+        memcpy(((uint8_t *) header) + length, proto->addr->value, proto->addr->length);
         length += proto->addr->length;
-        bzero((( uint8_t * ) header ) + length, device->addr->length );
+        bzero(((uint8_t *) header) + length, device->addr->length);
         length += device->addr->length;
-        memcpy((( uint8_t * ) header ) + length, target->value, target->length );
-        if( packet_set_addr( packet, ( uint8_t * ) device->addr->value, ( uint8_t * ) device->broadcast_addr->value, CONVERT_SIZE( char, uint8_t, device->addr->length )) != EOK ){
-                pq_release( arp_globals.net_phone, packet_get_id( packet ));
+        memcpy(((uint8_t *) header) + length, target->value, target->length);
+        if(packet_set_addr(packet, (uint8_t *) device->addr->value, (uint8_t *) device->broadcast_addr->value, CONVERT_SIZE(char, uint8_t, device->addr->length)) != EOK){
+                pq_release(arp_globals.net_phone, packet_get_id(packet));
                 return NULL;
         }
-        nil_send_msg( device->phone, device_id, packet, SERVICE_ARP );
+        nil_send_msg(device->phone, device_id, packet, SERVICE_ARP);
         return NULL;
 }
 
-int arp_receive_message( device_id_t device_id, packet_t packet ){
+int arp_receive_message(device_id_t device_id, packet_t packet){
         ERROR_DECLARE;
 
-        size_t                          length;
-        arp_header_ref          header;
-        arp_device_ref          device;
-        arp_proto_ref           proto;
-        measured_string_ref     hw_source;
-        uint8_t *                       src_hw;
-        uint8_t *                       src_proto;
-        uint8_t *                       des_hw;
-        uint8_t *                       des_proto;
-
-        length = packet_get_data_length( packet );
-        if( length <= sizeof( arp_header_t )) return EINVAL;
-        device = arp_cache_find( & arp_globals.cache, device_id );
-        if( ! device ) return ENOENT;
-        header = ( arp_header_ref ) packet_get_data( packet );
-        if(( ntohs( header->hardware ) != device->hardware )
-        || ( length < sizeof( arp_header_t ) + header->hardware_length * 2u + header->protocol_length * 2u )){
+        size_t length;
+        arp_header_ref header;
+        arp_device_ref device;
+        arp_proto_ref proto;
+        measured_string_ref hw_source;
+        uint8_t * src_hw;
+        uint8_t * src_proto;
+        uint8_t * des_hw;
+        uint8_t * des_proto;
+
+        length = packet_get_data_length(packet);
+        if(length <= sizeof(arp_header_t)){
                 return EINVAL;
         }
-        proto = arp_protos_find( & device->protos, protocol_unmap( device->service, ntohs( header->protocol )));
-        if( ! proto ) return ENOENT;
-        src_hw = (( uint8_t * ) header ) + sizeof( arp_header_t );
+        device = arp_cache_find(&arp_globals.cache, device_id);
+        if(! device){
+                return ENOENT;
+        }
+        header = (arp_header_ref) packet_get_data(packet);
+        if((ntohs(header->hardware) != device->hardware)
+                || (length < sizeof(arp_header_t) + header->hardware_length * 2u + header->protocol_length * 2u)){
+                return EINVAL;
+        }
+        proto = arp_protos_find(&device->protos, protocol_unmap(device->service, ntohs(header->protocol)));
+        if(! proto){
+                return ENOENT;
+        }
+        src_hw = ((uint8_t *) header) + sizeof(arp_header_t);
         src_proto = src_hw + header->hardware_length;
         des_hw = src_proto + header->protocol_length;
         des_proto = des_hw + header->hardware_length;
-        hw_source = arp_addr_find( & proto->addresses, ( char * ) src_proto, CONVERT_SIZE( uint8_t, char, header->protocol_length ));
+        hw_source = arp_addr_find(&proto->addresses, (char *) src_proto, CONVERT_SIZE(uint8_t, char, header->protocol_length));
         // exists?
-        if( hw_source ){
-                if( hw_source->length != CONVERT_SIZE( uint8_t, char, header->hardware_length )){
+        if(hw_source){
+                if(hw_source->length != CONVERT_SIZE(uint8_t, char, header->hardware_length)){
                         return EINVAL;
                 }
-                memcpy( hw_source->value, src_hw, hw_source->length );
+                memcpy(hw_source->value, src_hw, hw_source->length);
         }
         // is my protocol address?
-        if( proto->addr->length != CONVERT_SIZE( uint8_t, char, header->protocol_length )){
+        if(proto->addr->length != CONVERT_SIZE(uint8_t, char, header->protocol_length)){
                 return EINVAL;
         }
-        if( ! str_lcmp( proto->addr->value, ( char * ) des_proto, proto->addr->length )){
+        if(! str_lcmp(proto->addr->value, (char *) des_proto, proto->addr->length)){
                 // not already upadted?
-                if( ! hw_source ){
-                        hw_source = measured_string_create_bulk(( char * ) src_hw, CONVERT_SIZE( uint8_t, char, header->hardware_length ));
-                        if( ! hw_source ) return ENOMEM;
-                        ERROR_PROPAGATE( arp_addr_add( & proto->addresses, ( char * ) src_proto, CONVERT_SIZE( uint8_t, char, header->protocol_length ), hw_source ));
-                }
-                if( ntohs( header->operation ) == ARPOP_REQUEST ){
-                        header->operation = htons( ARPOP_REPLY );
-                        memcpy( des_proto, src_proto, header->protocol_length );
-                        memcpy( src_proto, proto->addr->value, header->protocol_length );
-                        memcpy( src_hw, device->addr->value, device->packet_dimension.addr_len );
-                        memcpy( des_hw, hw_source->value, header->hardware_length );
-                        ERROR_PROPAGATE( packet_set_addr( packet, src_hw, des_hw, header->hardware_length ));
-                        nil_send_msg( device->phone, device_id, packet, SERVICE_ARP );
+                if(! hw_source){
+                        hw_source = measured_string_create_bulk((char *) src_hw, CONVERT_SIZE(uint8_t, char, header->hardware_length));
+                        if(! hw_source){
+                                return ENOMEM;
+                        }
+                        ERROR_PROPAGATE(arp_addr_add(&proto->addresses, (char *) src_proto, CONVERT_SIZE(uint8_t, char, header->protocol_length), hw_source));
+                }
+                if(ntohs(header->operation) == ARPOP_REQUEST){
+                        header->operation = htons(ARPOP_REPLY);
+                        memcpy(des_proto, src_proto, header->protocol_length);
+                        memcpy(src_proto, proto->addr->value, header->protocol_length);
+                        memcpy(src_hw, device->addr->value, device->packet_dimension.addr_len);
+                        memcpy(des_hw, hw_source->value, header->hardware_length);
+                        ERROR_PROPAGATE(packet_set_addr(packet, src_hw, des_hw, header->hardware_length));
+                        nil_send_msg(device->phone, device_id, packet, SERVICE_ARP);
                         return 1;
                 }
@@ -482 +510 @@
 }
 
-void arp_clear_device( arp_device_ref device ){
-        int                             count;
-        arp_proto_ref   proto;
-
-        for( count = arp_protos_count( & device->protos ) - 1; count >= 0; -- count ){
-                proto = arp_protos_get_index( & device->protos, count );
-                if( proto ){
-                        if( proto->addr ) free( proto->addr );
-                        if( proto->addr_data ) free( proto->addr_data );
-                        arp_addr_destroy( & proto->addresses );
-                }
-        }
-        arp_protos_clear( & device->protos );
-}
-
-int arp_connect_module( services_t service ){
-        if( service != SERVICE_ARP ) return EINVAL;
-        return EOK;
-}
-
-int arp_mtu_changed_message( device_id_t device_id, size_t mtu ){
-        arp_device_ref  device;
-
-        fibril_rwlock_write_lock( & arp_globals.lock );
-        device = arp_cache_find( & arp_globals.cache, device_id );
-        if( ! device ){
-                fibril_rwlock_write_unlock( & arp_globals.lock );
+void arp_clear_device(arp_device_ref device){
+        int count;
+        arp_proto_ref proto;
+
+        for(count = arp_protos_count(&device->protos) - 1; count >= 0; -- count){
+                proto = arp_protos_get_index(&device->protos, count);
+                if(proto){
+                        if(proto->addr){
+                                free(proto->addr);
+                        }
+                        if(proto->addr_data){
+                                free(proto->addr_data);
+                        }
+                        arp_addr_destroy(&proto->addresses);
+                }
+        }
+        arp_protos_clear(&device->protos);
+}
+
+int arp_connect_module(services_t service){
+        if(service != SERVICE_ARP){
+                return EINVAL;
+        }
+        return EOK;
+}
+
+int arp_mtu_changed_message(device_id_t device_id, size_t mtu){
+        arp_device_ref device;
+
+        fibril_rwlock_write_lock(&arp_globals.lock);
+        device = arp_cache_find(&arp_globals.cache, device_id);
+        if(! device){
+                fibril_rwlock_write_unlock(&arp_globals.lock);
                 return ENOENT;
         }
         device->packet_dimension.content = mtu;
-        printf( "arp - device %d changed mtu to %d\n\n", device_id, mtu );
-        fibril_rwlock_write_unlock( & arp_globals.lock );
-        return EOK;
-}
-
-int arp_message( ipc_callid_t callid, ipc_call_t * call, ipc_call_t * answer, int * answer_count ){
+        printf("arp - device %d changed mtu to %d\n\n", device_id, mtu);
+        fibril_rwlock_write_unlock(&arp_globals.lock);
+        return EOK;
+}
+
+int arp_message(ipc_callid_t callid, ipc_call_t * call, ipc_call_t * answer, int * answer_count){
         ERROR_DECLARE;
 
-        measured_string_ref     address;
-        measured_string_ref     translation;
-        char *                          data;
-        packet_t                        packet;
-        packet_t                        next;
-
-//      printf( "message %d - %d\n", IPC_GET_METHOD( * call ), NET_ARP_FIRST );
-        * answer_count = 0;
-        switch( IPC_GET_METHOD( * call )){
+        measured_string_ref address;
+        measured_string_ref translation;
+        char * data;
+        packet_t packet;
+        packet_t next;
+
+//      printf("message %d - %d\n", IPC_GET_METHOD(*call), NET_ARP_FIRST);
+        *answer_count = 0;
+        switch(IPC_GET_METHOD(*call)){
                 case IPC_M_PHONE_HUNGUP:
                         return EOK;
                 case NET_ARP_DEVICE:
-                        ERROR_PROPAGATE( measured_strings_receive( & address, & data, 1 ));
-                        if( ERROR_OCCURRED( arp_device_message( IPC_GET_DEVICE( call ), IPC_GET_SERVICE( call ), ARP_GET_NETIF( call ), address ))){
-                                free( address );
-                                free( data );
+                        ERROR_PROPAGATE(measured_strings_receive(&address, &data, 1));
+                        if(ERROR_OCCURRED(arp_device_message(IPC_GET_DEVICE(call), IPC_GET_SERVICE(call), ARP_GET_NETIF(call), address))){
+                                free(address);
+                                free(data);
                         }
                         return ERROR_CODE;
                 case NET_ARP_TRANSLATE:
-                        ERROR_PROPAGATE( measured_strings_receive( & address, & data, 1 ));
-                        fibril_rwlock_read_lock( & arp_globals.lock );
-                        translation = arp_translate_message( IPC_GET_DEVICE( call ), IPC_GET_SERVICE( call ), address );
-                        free( address );
-                        free( data );
-                        if( ! translation ){
-                                fibril_rwlock_read_unlock( & arp_globals.lock );
+                        ERROR_PROPAGATE(measured_strings_receive(&address, &data, 1));
+                        fibril_rwlock_read_lock(&arp_globals.lock);
+                        translation = arp_translate_message(IPC_GET_DEVICE(call), IPC_GET_SERVICE(call), address);
+                        free(address);
+                        free(data);
+                        if(! translation){
+                                fibril_rwlock_read_unlock(&arp_globals.lock);
                                 return ENOENT;
                         }
-                        ERROR_CODE = measured_strings_reply( translation, 1 );
-                        fibril_rwlock_read_unlock( & arp_globals.lock );
+                        ERROR_CODE = measured_strings_reply(translation, 1);
+                        fibril_rwlock_read_unlock(&arp_globals.lock);
                         return ERROR_CODE;
                 case NET_ARP_CLEAR_DEVICE:
-                        return arp_clear_device_req( 0, IPC_GET_DEVICE( call ));
+                        return arp_clear_device_req(0, IPC_GET_DEVICE(call));
                 case NET_ARP_CLEAR_ADDRESS:
-                        ERROR_PROPAGATE( measured_strings_receive( & address, & data, 1 ));
-                        arp_clear_address_req( 0, IPC_GET_DEVICE( call ), IPC_GET_SERVICE( call ), address );
-                        free( address );
-                        free( data );
+                        ERROR_PROPAGATE(measured_strings_receive(&address, &data, 1));
+                        arp_clear_address_req(0, IPC_GET_DEVICE(call), IPC_GET_SERVICE(call), address);
+                        free(address);
+                        free(data);
                         return EOK;
                 case NET_ARP_CLEAN_CACHE:
-                        return arp_clean_cache_req( 0 );
+                        return arp_clean_cache_req(0);
                 case NET_IL_DEVICE_STATE:
                         // do nothing - keep the cache
                         return EOK;
                 case NET_IL_RECEIVED:
-                        if( ! ERROR_OCCURRED( packet_translate( arp_globals.net_phone, & packet, IPC_GET_PACKET( call )))){
-                                fibril_rwlock_read_lock( & arp_globals.lock );
+                        if(! ERROR_OCCURRED(packet_translate(arp_globals.net_phone, &packet, IPC_GET_PACKET(call)))){
+                                fibril_rwlock_read_lock(&arp_globals.lock);
                                 do{
-                                        next = pq_detach( packet );
-                                        ERROR_CODE = arp_receive_message( IPC_GET_DEVICE( call ), packet );
-                                        if( ERROR_CODE != 1 ) pq_release( arp_globals.net_phone, packet_get_id( packet ));
+                                        next = pq_detach(packet);
+                                        ERROR_CODE = arp_receive_message(IPC_GET_DEVICE(call), packet);
+                                        if(ERROR_CODE != 1){
+                                                pq_release(arp_globals.net_phone, packet_get_id(packet));
+                                        }
                                         packet = next;
-                                }while( packet );
-                                fibril_rwlock_read_unlock( & arp_globals.lock );
+                                }while(packet);
+                                fibril_rwlock_read_unlock(&arp_globals.lock);
                         }
                         return ERROR_CODE;
                 case NET_IL_MTU_CHANGED:
-                        return arp_mtu_changed_message( IPC_GET_DEVICE( call ), IPC_GET_MTU( call ));
+                        return arp_mtu_changed_message(IPC_GET_DEVICE(call), IPC_GET_MTU(call));
         }
         return ENOTSUP;

uspace/srv/net/il/arp/arp.h

@@ -80 +80 @@
  *  @see device.h
  */
-DEVICE_MAP_DECLARE( arp_cache, arp_device_t )
+DEVICE_MAP_DECLARE(arp_cache, arp_device_t)
 
 /** ARP protocol map.
@@ -86 +86 @@
  *  @see int_map.h
  */
-INT_MAP_DECLARE( arp_protos, arp_proto_t )
+INT_MAP_DECLARE(arp_protos, arp_proto_t)
 
 /** ARP address map.
@@ -92 +92 @@
  *  @see generic_char_map.h
  */
-GENERIC_CHAR_MAP_DECLARE( arp_addr, measured_string_t )
+GENERIC_CHAR_MAP_DECLARE(arp_addr, measured_string_t)
 
 /** ARP device specific data.
@@ -99 +99 @@
         /** Device identifier.
          */
-        device_id_t                     device_id;
+        device_id_t device_id;
         /** Hardware type.
          */
-        hw_type_t                       hardware;
+        hw_type_t hardware;
         /** Packet dimension.
          */
-        packet_dimension_t      packet_dimension;
+        packet_dimension_t packet_dimension;
         /** Actual device hardware address.
          */
-        measured_string_ref     addr;
+        measured_string_ref addr;
         /** Actual device hardware address data.
          */
-        char *                          addr_data;
+        char * addr_data;
         /** Broadcast device hardware address.
          */
-        measured_string_ref     broadcast_addr;
+        measured_string_ref broadcast_addr;
         /** Broadcast device hardware address data.
          */
-        char *                          broadcast_data;
+        char * broadcast_data;
         /** Device module service.
          */
-        services_t                      service;
+        services_t service;
         /** Device module phone.
          */
-        int                                     phone;
+        int phone;
         /** Protocol map.
          *  Address map for each protocol.
          */
-        arp_protos_t            protos;
+        arp_protos_t protos;
 };
 
@@ -135 +135 @@
         /** Protocol service.
          */
-        services_t                      service;
+        services_t service;
         /** Actual device protocol address.
          */
-        measured_string_ref     addr;
+        measured_string_ref addr;
         /** Actual device protocol address data.
          */
-        char *                          addr_data;
+        char * addr_data;
         /** Address map.
          */
-        arp_addr_t                      addresses;
+        arp_addr_t addresses;
 };
 
@@ -152 +152 @@
         /** Networking module phone.
          */
-        int                     net_phone;
+        int net_phone;
         /** Safety lock.
          */
-        fibril_rwlock_t         lock;
+        fibril_rwlock_t lock;
         /** ARP address cache.
          */
-        arp_cache_t     cache;
+        arp_cache_t cache;
         /** The client connection processing function.
          *  The module skeleton propagates its own one.

uspace/srv/net/il/arp/arp_header.h

@@ -57 +57 @@
          *  @see hardware.h
          */
-        uint16_t        hardware;
+        uint16_t hardware;
         /** Protocol identifier.
          */
-        uint16_t        protocol;
+        uint16_t protocol;
         /** Hardware address length in bytes.
          */
-        uint8_t         hardware_length;
+        uint8_t hardware_length;
         /** Protocol address length in bytes.
          */
-        uint8_t         protocol_length;
+        uint8_t protocol_length;
         /** ARP packet type.
          *  @see arp_oc.h
          */
-        uint16_t        operation;
+        uint16_t operation;
 } __attribute__ ((packed));
 

uspace/srv/net/il/arp/arp_messages.h

@@ -75 +75 @@
  *  @param[in] call The message call structure.
  */
-#define ARP_GET_NETIF( call )           ( services_t ) IPC_GET_ARG2( * call )
+#define ARP_GET_NETIF(call)             (services_t) IPC_GET_ARG2(*call)
 
 /*@}*/

uspace/srv/net/il/arp/arp_module.c

@@ -61 +61 @@
  *  @see NAME
  */
-void    module_print_name( void );
+void module_print_name(void);
 
 /** Starts the ARP module.
@@ -70 +70 @@
  *  @returns Other error codes as defined for the REGISTER_ME() macro function.
  */
-int     module_start( async_client_conn_t client_connection );
+int module_start(async_client_conn_t client_connection);
 
 /** Processes the ARP message.
@@ -80 +80 @@
  *  @returns Other error codes as defined for the arp_message() function.
  */
-int     module_message( ipc_callid_t callid, ipc_call_t * call, ipc_call_t * answer, int * answer_count );
+int module_message(ipc_callid_t callid, ipc_call_t * call, ipc_call_t * answer, int * answer_count);
 
 /** ARP module global data.
@@ -86 +86 @@
 extern arp_globals_t    arp_globals;
 
-void module_print_name( void ){
-        printf( "%s", NAME );
+void module_print_name(void){
+        printf("%s", NAME);
 }
 
-int module_start( async_client_conn_t client_connection ){
+int module_start(async_client_conn_t client_connection){
         ERROR_DECLARE;
 
-        ipcarg_t        phonehash;
+        ipcarg_t phonehash;
 
-        async_set_client_connection( client_connection );
-        arp_globals.net_phone = net_connect_module( SERVICE_NETWORKING );
-        ERROR_PROPAGATE( pm_init());
-        if( ERROR_OCCURRED( arp_initialize( client_connection ))
-        || ERROR_OCCURRED( REGISTER_ME( SERVICE_ARP, & phonehash ))){
+        async_set_client_connection(client_connection);
+        arp_globals.net_phone = net_connect_module(SERVICE_NETWORKING);
+        ERROR_PROPAGATE(pm_init());
+        if(ERROR_OCCURRED(arp_initialize(client_connection))
+                || ERROR_OCCURRED(REGISTER_ME(SERVICE_ARP, &phonehash))){
                 pm_destroy();
                 return ERROR_CODE;
@@ -110 +110 @@
 }
 
-int     module_message( ipc_callid_t callid, ipc_call_t * call, ipc_call_t * answer, int * answer_count ){
-        return arp_message( callid, call, answer, answer_count );
+int module_message(ipc_callid_t callid, ipc_call_t * call, ipc_call_t * answer, int * answer_count){
+        return arp_message(callid, call, answer, answer_count);
 }
 

uspace/srv/net/il/arp/arp_module.h

@@ -46 +46 @@
  *  @returns ENOMEM if there is not enough memory left.
  */
-int     arp_initialize( async_client_conn_t client_connection );
+int arp_initialize(async_client_conn_t client_connection);
 
 /** Processes the ARP message.
@@ -58 +58 @@
  *  @see IS_NET_ARP_MESSAGE()
  */
-int     arp_message( ipc_callid_t callid, ipc_call_t * call, ipc_call_t * answer, int * answer_count );
+int arp_message(ipc_callid_t callid, ipc_call_t * call, ipc_call_t * answer, int * answer_count);
 
 #endif

uspace/srv/net/il/arp/arp_remote.c

@@ -52 +52 @@
 #include "arp_messages.h"
 
-int arp_device_req( int arp_phone, device_id_t device_id, services_t protocol, services_t netif, measured_string_ref address ){
-        aid_t                   message_id;
-        ipcarg_t                result;
+int arp_device_req(int arp_phone, device_id_t device_id, services_t protocol, services_t netif, measured_string_ref address){
+        aid_t message_id;
+        ipcarg_t result;
 
-        message_id = async_send_3( arp_phone, NET_ARP_DEVICE, ( ipcarg_t ) device_id, protocol, netif, NULL );
-        measured_strings_send( arp_phone, address, 1 );
-        async_wait_for( message_id, & result );
-        return ( int ) result;
+        message_id = async_send_3(arp_phone, NET_ARP_DEVICE, (ipcarg_t) device_id, protocol, netif, NULL);
+        measured_strings_send(arp_phone, address, 1);
+        async_wait_for(message_id, &result);
+        return (int) result;
 }
 
-int arp_translate_req( int arp_phone, device_id_t device_id, services_t protocol, measured_string_ref address, measured_string_ref * translation, char ** data ){
-        return generic_translate_req( arp_phone, NET_ARP_TRANSLATE, device_id, protocol, address, 1, translation, data );
+int arp_translate_req(int arp_phone, device_id_t device_id, services_t protocol, measured_string_ref address, measured_string_ref * translation, char ** data){
+        return generic_translate_req(arp_phone, NET_ARP_TRANSLATE, device_id, protocol, address, 1, translation, data);
 }
 
-int arp_clear_device_req( int arp_phone, device_id_t device_id ){
-        return ( int ) async_req_1_0( arp_phone, NET_ARP_CLEAR_DEVICE, ( ipcarg_t ) device_id );
+int arp_clear_device_req(int arp_phone, device_id_t device_id){
+        return (int) async_req_1_0(arp_phone, NET_ARP_CLEAR_DEVICE, (ipcarg_t) device_id);
 }
 
-int arp_clear_address_req( int arp_phone, device_id_t device_id, services_t protocol, measured_string_ref address ){
-        aid_t                   message_id;
-        ipcarg_t                result;
+int arp_clear_address_req(int arp_phone, device_id_t device_id, services_t protocol, measured_string_ref address){
+        aid_t message_id;
+        ipcarg_t result;
 
-        message_id = async_send_2( arp_phone, NET_ARP_CLEAR_ADDRESS, ( ipcarg_t ) device_id, protocol, NULL );
-        measured_strings_send( arp_phone, address, 1 );
-        async_wait_for( message_id, & result );
-        return ( int ) result;
+        message_id = async_send_2(arp_phone, NET_ARP_CLEAR_ADDRESS, (ipcarg_t) device_id, protocol, NULL);
+        measured_strings_send(arp_phone, address, 1);
+        async_wait_for(message_id, &result);
+        return (int) result;
 }
 
-int arp_clean_cache_req( int arp_phone ){
-        return ( int ) async_req_0_0( arp_phone, NET_ARP_CLEAN_CACHE );
+int arp_clean_cache_req(int arp_phone){
+        return (int) async_req_0_0(arp_phone, NET_ARP_CLEAN_CACHE);
 }
 
-int arp_connect_module( services_t service ){
-        if( service != SERVICE_ARP ) return EINVAL;
-        return connect_to_service( SERVICE_ARP );
+int arp_connect_module(services_t service){
+        if(service != SERVICE_ARP){
+                return EINVAL;
+        }
+        return connect_to_service(SERVICE_ARP);
 }
 
-task_id_t arp_task_get_id( void ){
+task_id_t arp_task_get_id(void){
         return 0;
 }

uspace/srv/net/il/il_messages.h

@@ -78 +78 @@
  *  @param[in] call The message call structure.
  */
-#define IL_GET_PROTO( call )            ( int ) IPC_GET_ARG1( * call )
+#define IL_GET_PROTO(call)              (int) IPC_GET_ARG1(*call)
 
 /** Returns the registering service message parameter.
  *  @param[in] call The message call structure.
  */
-#define IL_GET_SERVICE( call )          ( services_t ) IPC_GET_ARG2( * call )
+#define IL_GET_SERVICE(call)            (services_t) IPC_GET_ARG2(*call)
 
 /*@}*/

uspace/srv/net/il/ip/ip.c

@@ -108 +108 @@
 /** IP packet address length.
  */
-#define IP_ADDR                                                 sizeof( struct sockaddr_in6 )
+#define IP_ADDR                                                 sizeof(struct sockaddr_in6)
 
 /** IP packet prefix length.
  */
-#define IP_PREFIX                                               sizeof( ip_header_t )
+#define IP_PREFIX                                               sizeof(ip_header_t)
 
 /** IP packet suffix length.
@@ -124 +124 @@
 /** The IP localhost address.
  */
-#define IPV4_LOCALHOST_ADDRESS  htonl(( 127 << 24 ) + 1 )
+#define IPV4_LOCALHOST_ADDRESS  htonl((127 << 24) + 1)
 
 /** IP global data.
@@ -130 +130 @@
 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 )
+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.
@@ -142 +142 @@
  *  @returns ENOENT if device is not found.
  */
-int     ip_mtu_changed_message( device_id_t device_id, size_t mtu );
+int ip_mtu_changed_message(device_id_t device_id, size_t mtu);
 
 /** Updates the device state.
@@ -150 +150 @@
  *  @returns ENOENT if device is not found.
  */
-int     ip_device_state_message( device_id_t device_id, device_state_t state );
+int ip_device_state_message(device_id_t device_id, device_state_t state);
 
 /** Returns the device packet dimensions for sending.
@@ -162 +162 @@
  *  @returns EOK on success.
  */
-int     ip_packet_size_message( device_id_t device_id, size_t * addr_len, size_t * prefix, size_t * content, size_t * suffix );
+int ip_packet_size_message(device_id_t device_id, size_t * addr_len, size_t * prefix, size_t * content, size_t * suffix);
 
 /** Registers the transport layer protocol.
@@ -175 +175 @@
  *  @returns ENOMEM if there is not enough memory left.
  */
-int     ip_register( int protocol, services_t service, int phone, tl_received_msg_t tl_received_msg );
+int ip_register(int protocol, services_t service, int phone, tl_received_msg_t tl_received_msg);
 
 /** Initializes a new network interface specific data.
@@ -192 +192 @@
  *  @returns Other error codes as defined for the nil_packet_size_req() function.
  */
-int     ip_netif_initialize( ip_netif_ref ip_netif );
+int ip_netif_initialize(ip_netif_ref ip_netif);
 
 /** Sends the packet or the packet queue via the specified route.
@@ -206 +206 @@
  *  @returns Other error codes as defined for the ip_prepare_packet() function.
  */
-int     ip_send_route( packet_t packet, ip_netif_ref netif, ip_route_ref route, in_addr_t * src, in_addr_t dest, services_t error );
+int ip_send_route(packet_t packet, ip_netif_ref netif, ip_route_ref route, in_addr_t * src, in_addr_t dest, services_t error);
 
 /** Prepares the outgoing packet or the packet queue.
@@ -222 +222 @@
  *  @returns Other error codes as defined for the packet_set_addr() function.
  */
-int     ip_prepare_packet( in_addr_t * source, in_addr_t dest, packet_t packet, measured_string_ref destination );
+int ip_prepare_packet(in_addr_t * source, in_addr_t dest, packet_t packet, measured_string_ref destination);
 
 /** Checks the packet queue lengths and fragments the packets if needed.
@@ -235 +235 @@
  *  @returns NULL if there are no packets left.
  */
-packet_t        ip_split_packet( packet_t packet, size_t prefix, size_t content, size_t suffix, socklen_t addr_len, services_t error );
+packet_t ip_split_packet(packet_t packet, size_t prefix, size_t content, size_t suffix, socklen_t addr_len, services_t error);
 
 /** Checks the packet length and fragments it if needed.
@@ -255 +255 @@
  *  @returns Other error codes as defined for the ip_fragment_packet_data() function.
  */
-int     ip_fragment_packet( packet_t packet, size_t length, size_t prefix, size_t suffix, socklen_t addr_len );
+int ip_fragment_packet(packet_t packet, size_t length, size_t prefix, size_t suffix, socklen_t addr_len);
 
 /** Fragments the packet from the end.
@@ -271 +271 @@
  *  @returns Other error codes as defined for the pq_insert_after() function.
  */
-int     ip_fragment_packet_data( packet_t packet, packet_t new_packet, ip_header_ref header, ip_header_ref new_header, size_t length, const struct sockaddr * src, const struct sockaddr * dest, socklen_t addrlen );
+int ip_fragment_packet_data(packet_t packet, packet_t new_packet, ip_header_ref header, ip_header_ref new_header, size_t length, const struct sockaddr * src, const struct sockaddr * dest, socklen_t addrlen);
 
 /** Prefixes a middle fragment header based on the last fragment header to the packet.
@@ -279 +279 @@
  *  @returns NULL on error.
  */
-ip_header_ref   ip_create_middle_header( packet_t packet, ip_header_ref last );
+ip_header_ref ip_create_middle_header(packet_t packet, ip_header_ref last);
 
 /** Copies the fragment header.
@@ -286 +286 @@
  *  @param[in] first The original header to be copied.
  */
-void ip_create_last_header( ip_header_ref last, ip_header_ref first );
+void ip_create_last_header(ip_header_ref last, ip_header_ref first);
 
 /** Returns the network interface's IP address.
@@ -293 +293 @@
  *  @returns NULL if no IP address was found.
  */
-in_addr_t *     ip_netif_address( ip_netif_ref netif );
+in_addr_t * ip_netif_address(ip_netif_ref netif);
 
 /** Searches all network interfaces if there is a suitable route.
@@ -300 +300 @@
  *  @returns NULL if no route was found.
  */
-ip_route_ref    ip_find_route( in_addr_t destination );
+ip_route_ref ip_find_route(in_addr_t destination);
 
 /** Searches the network interfaces if there is a suitable route.
@@ -308 +308 @@
  *  @returns NULL if no route was found.
  */
-ip_route_ref    ip_netif_find_route( ip_netif_ref netif, in_addr_t destination );
+ip_route_ref ip_netif_find_route(ip_netif_ref netif, in_addr_t destination);
 
 /** Processes the received IP packet or the packet queue one by one.
@@ -321 +321 @@
  *  @returns ENOMEM if there is not enough memory left.
  */
-int     ip_receive_message( device_id_t device_id, packet_t packet );
+int ip_receive_message(device_id_t device_id, packet_t packet);
 
 /** Processes the received packet.
@@ -338 +338 @@
  *  @returns ENOENT if the packet is for another host and the routing is disabled.
  */
-int     ip_process_packet( device_id_t device_id, packet_t packet );
+int ip_process_packet(device_id_t device_id, packet_t packet);
 
 /** Returns the packet destination address from the IP header.
@@ -344 +344 @@
  *  @returns The packet destination address.
  */
-in_addr_t       ip_get_destination( ip_header_ref header );
+in_addr_t ip_get_destination(ip_header_ref header);
 
 /** Delivers the packet to the local host.
@@ -361 +361 @@
  *  @returns Other error codes as defined for the protocol specific tl_received_msg function.
  */
-int     ip_deliver_local( device_id_t device_id, packet_t packet, ip_header_ref header, services_t error );
+int ip_deliver_local(device_id_t device_id, packet_t packet, ip_header_ref header, services_t error);
 
 /** Prepares the ICMP notification packet.
@@ -374 +374 @@
  *  @returns EINVAL if the ip_prepare_icmp() fails.
  */
-int     ip_prepare_icmp_and_get_phone( services_t error, packet_t packet, ip_header_ref header );
+int ip_prepare_icmp_and_get_phone(services_t error, packet_t packet, ip_header_ref header);
 
 /** Returns the ICMP phone.
@@ -381 +381 @@
  *  @returns ENOENT if the ICMP is not registered.
  */
-int     ip_get_icmp_phone( void );
+int ip_get_icmp_phone(void);
 
 /** Prepares the ICMP notification packet.
@@ -395 +395 @@
  *  @returns Other error codes as defined for the packet_set_addr().
  */
-int     ip_prepare_icmp( packet_t packet, ip_header_ref header );
+int ip_prepare_icmp(packet_t packet, ip_header_ref header);
 
 /** Releases the packet and returns the result.
@@ -402 +402 @@
  *  @return The result parameter.
  */
-int     ip_release_and_return( packet_t packet, int result );
-
-int ip_initialize( async_client_conn_t client_connection ){
+int ip_release_and_return(packet_t packet, int result);
+
+int ip_initialize(async_client_conn_t client_connection){
         ERROR_DECLARE;
 
-        fibril_rwlock_initialize( & ip_globals.lock );
-        fibril_rwlock_write_lock( & ip_globals.lock );
-        fibril_rwlock_initialize( & ip_globals.protos_lock );
-        fibril_rwlock_initialize( & ip_globals.netifs_lock );
+        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;
@@ -416 +416 @@
         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 ));
+        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 );
+        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 ){
+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 );
+        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;
         }
@@ -442 +444 @@
         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 );
+        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;
+        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" );
+        printf("New device registered:\n\tid\t= %d\n\tphone\t= %d\n\tIPV\t= %d\n", ip_netif->device_id, ip_netif->phone, ip_netif->ipv);
+        printf("\tconfiguration\t= %s\n", ip_netif->dhcp ? "dhcp" : "static");
         // TODO ipv6 addresses
-        data = ( char * ) malloc( INET_ADDRSTRLEN );
-        if( data ){
-                for( index = 0; index < ip_routes_count( & ip_netif->routes ); ++ index ){
-                        route = ip_routes_get_index( & ip_netif->routes, index );
-                        if( route ){
-                                printf( "\tRouting %d:\n", index );
-                                inet_ntop( AF_INET, ( uint8_t * ) & route->address.s_addr, data, INET_ADDRSTRLEN );
-                                printf( "\t\taddress\t= %s\n", data );
-                                inet_ntop( AF_INET, ( uint8_t * ) & route->netmask.s_addr, data, INET_ADDRSTRLEN );
-                                printf( "\t\tnetmask\t= %s\n", data );
-                                inet_ntop( AF_INET, ( uint8_t * ) & route->gateway.s_addr, data, INET_ADDRSTRLEN );
-                                printf( "\t\tgateway\t= %s\n", data );
-                        }
-                }
-                inet_ntop( AF_INET, ( uint8_t * ) & ip_netif->broadcast.s_addr, data, INET_ADDRSTRLEN );
-                printf( "\t\tbroadcast\t= %s\n", data );
-                free( data );
-        }
-        fibril_rwlock_write_unlock( & ip_globals.netifs_lock );
+        data = (char *) malloc(INET_ADDRSTRLEN);
+        if(data){
+                for(index = 0; index < ip_routes_count(&ip_netif->routes); ++ index){
+                        route = ip_routes_get_index(&ip_netif->routes, index);
+                        if(route){
+                                printf("\tRouting %d:\n", index);
+                                inet_ntop(AF_INET, (uint8_t *) &route->address.s_addr, data, INET_ADDRSTRLEN);
+                                printf("\t\taddress\t= %s\n", data);
+                                inet_ntop(AF_INET, (uint8_t *) &route->netmask.s_addr, data, INET_ADDRSTRLEN);
+                                printf("\t\tnetmask\t= %s\n", data);
+                                inet_ntop(AF_INET, (uint8_t *) &route->gateway.s_addr, data, INET_ADDRSTRLEN);
+                                printf("\t\tgateway\t= %s\n", data);
+                        }
+                }
+                inet_ntop(AF_INET, (uint8_t *) &ip_netif->broadcast.s_addr, data, INET_ADDRSTRLEN);
+                printf("\t\tbroadcast\t= %s\n", data);
+                free(data);
+        }
+        fibril_rwlock_write_unlock(&ip_globals.netifs_lock);
         return EOK;
 }
 
-int ip_netif_initialize( ip_netif_ref ip_netif ){
+int ip_netif_initialize(ip_netif_ref ip_netif){
         ERROR_DECLARE;
 
-        measured_string_t       names[] = {{ str_dup("IPV"), 3 }, { str_dup("IP_CONFIG"), 9 }, { str_dup("IP_ADDR"), 7 }, { str_dup("IP_NETMASK"), 10 }, { str_dup("IP_GATEWAY"), 10 }, { str_dup("IP_BROADCAST"), 12 }, { str_dup("ARP"), 3 }, { str_dup("IP_ROUTING"), 10 }};
-        measured_string_ref     configuration;
-        size_t                          count = sizeof( names ) / sizeof( measured_string_t );
-        char *                          data;
-        measured_string_t       address;
-        int                                     index;
-        ip_route_ref            route;
-        in_addr_t                       gateway;
+        measured_string_t names[] = {{str_dup("IPV"), 3}, {str_dup("IP_CONFIG"), 9}, {str_dup("IP_ADDR"), 7}, {str_dup("IP_NETMASK"), 10}, {str_dup("IP_GATEWAY"), 10}, {str_dup("IP_BROADCAST"), 12}, {str_dup("ARP"), 3}, {str_dup("IP_ROUTING"), 10}};
+        measured_string_ref configuration;
+        size_t count = sizeof(names) / sizeof(measured_string_t);
+        char * data;
+        measured_string_t address;
+        int index;
+        ip_route_ref route;
+        in_addr_t gateway;
 
         ip_netif->arp = NULL;
@@ -493 +497 @@
         ip_netif->dhcp = false;
         ip_netif->routing = NET_DEFAULT_IP_ROUTING;
-        configuration = & names[ 0 ];
+        configuration = &names[0];
         // get configuration
-        ERROR_PROPAGATE( net_get_device_conf_req( ip_globals.net_phone, ip_netif->device_id, & configuration, count, & data ));
-        if( configuration ){
-                if( configuration[ 0 ].value ){
-                        ip_netif->ipv = strtol( configuration[ 0 ].value, NULL, 0 );
-                }
-                ip_netif->dhcp = ! str_lcmp( configuration[ 1 ].value, "dhcp", configuration[ 1 ].length );
-                if( ip_netif->dhcp ){
+        ERROR_PROPAGATE(net_get_device_conf_req(ip_globals.net_phone, ip_netif->device_id, &configuration, count, &data));
+        if(configuration){
+                if(configuration[0].value){
+                        ip_netif->ipv = strtol(configuration[0].value, NULL, 0);
+                }
+                ip_netif->dhcp = ! str_lcmp(configuration[1].value, "dhcp", configuration[1].length);
+                if(ip_netif->dhcp){
                         // TODO dhcp
-                        net_free_settings( configuration, data );
+                        net_free_settings(configuration, data);
                         return ENOTSUP;
-                }else if( ip_netif->ipv == IPV4 ){
-                        route = ( ip_route_ref ) malloc( sizeof( ip_route_t ));
-                        if( ! route ){
-                                net_free_settings( configuration, data );
+                }else if(ip_netif->ipv == IPV4){
+                        route = (ip_route_ref) malloc(sizeof(ip_route_t));
+                        if(! route){
+                                net_free_settings(configuration, data);
                                 return ENOMEM;
                         }
@@ -515 +519 @@
                         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 );
+                        index = ip_routes_add(&ip_netif->routes, route);
+                        if(index < 0){
+                                net_free_settings(configuration, data);
+                                free(route);
                                 return index;
                         }
-                        if( ERROR_OCCURRED( inet_pton( AF_INET, configuration[ 2 ].value, ( uint8_t * ) & route->address.s_addr ))
-                        || ERROR_OCCURRED( inet_pton( AF_INET, configuration[ 3 ].value, ( uint8_t * ) & route->netmask.s_addr ))
-                        || ( inet_pton( AF_INET, configuration[ 4 ].value, ( uint8_t * ) & gateway.s_addr ) == EINVAL )
-                        || ( inet_pton( AF_INET, configuration[ 5 ].value, ( uint8_t * ) & ip_netif->broadcast.s_addr ) == EINVAL )){
-                                net_free_settings( configuration, data );
+                        if(ERROR_OCCURRED(inet_pton(AF_INET, configuration[2].value, (uint8_t *) &route->address.s_addr))
+                                || ERROR_OCCURRED(inet_pton(AF_INET, configuration[3].value, (uint8_t *) &route->netmask.s_addr))
+                                || (inet_pton(AF_INET, configuration[4].value, (uint8_t *) &gateway.s_addr) == EINVAL)
+                                || (inet_pton(AF_INET, configuration[5].value, (uint8_t *) &ip_netif->broadcast.s_addr) == EINVAL)){
+                                net_free_settings(configuration, data);
                                 return EINVAL;
                         }
                 }else{
                         // TODO ipv6 in separate module
-                        net_free_settings( configuration, data );
+                        net_free_settings(configuration, data);
                         return ENOTSUP;
                 }
-                if( configuration[ 6 ].value ){
-                        ip_netif->arp = get_running_module( & ip_globals.modules, configuration[ 6 ].value );
-                        if( ! ip_netif->arp ){
-                                printf( "Failed to start the arp %s\n", configuration[ 6 ].value );
-                                net_free_settings( configuration, data );
+                if(configuration[6].value){
+                        ip_netif->arp = get_running_module(&ip_globals.modules, configuration[6].value);
+                        if(! ip_netif->arp){
+                                printf("Failed to start the arp %s\n", configuration[6].value);
+                                net_free_settings(configuration, data);
                                 return EINVAL;
                         }
                 }
-                if( configuration[ 7 ].value ){
-                        ip_netif->routing = ( configuration[ 7 ].value[ 0 ] == 'y' );
-                }
-                net_free_settings( configuration, data );
+                if(configuration[7].value){
+                        ip_netif->routing = (configuration[7].value[0] == 'y');
+                }
+                net_free_settings(configuration, data);
         }
         // binds the netif service which also initializes the device
-        ip_netif->phone = nil_bind_service( ip_netif->service, ( ipcarg_t ) ip_netif->device_id, SERVICE_IP, ip_globals.client_connection );
-        if( ip_netif->phone < 0 ){
-                printf( "Failed to contact the nil service %d\n", ip_netif->service );
+        ip_netif->phone = nil_bind_service(ip_netif->service, (ipcarg_t) ip_netif->device_id, SERVICE_IP, ip_globals.client_connection);
+        if(ip_netif->phone < 0){
+                printf("Failed to contact the nil service %d\n", ip_netif->service);
                 return ip_netif->phone;
         }
         // has to be after the device netif module initialization
-        if( ip_netif->arp ){
-                if( route ){
-                        address.value = ( char * ) & route->address.s_addr;
-                        address.length = CONVERT_SIZE( in_addr_t, char, 1 );
-                        ERROR_PROPAGATE( arp_device_req( ip_netif->arp->phone, ip_netif->device_id, SERVICE_IP, ip_netif->service, & address ));
+        if(ip_netif->arp){
+                if(route){
+                        address.value = (char *) &route->address.s_addr;
+                        address.length = CONVERT_SIZE(in_addr_t, char, 1);
+                        ERROR_PROPAGATE(arp_device_req(ip_netif->arp->phone, ip_netif->device_id, SERVICE_IP, ip_netif->service, &address));
                 }else{
                         ip_netif->arp = 0;
@@ -563 +567 @@
         }
         // get packet dimensions
-        ERROR_PROPAGATE( nil_packet_size_req( ip_netif->phone, ip_netif->device_id, & ip_netif->packet_dimension ));
-        if( ip_netif->packet_dimension.content < IP_MIN_CONTENT ){
-                printf( "Maximum transmission unit %d bytes is too small, at least %d bytes are needed\n", ip_netif->packet_dimension.content, IP_MIN_CONTENT );
+        ERROR_PROPAGATE(nil_packet_size_req(ip_netif->phone, ip_netif->device_id, &ip_netif->packet_dimension));
+        if(ip_netif->packet_dimension.content < IP_MIN_CONTENT){
+                printf("Maximum transmission unit %d bytes is too small, at least %d bytes are needed\n", ip_netif->packet_dimension.content, IP_MIN_CONTENT);
                 ip_netif->packet_dimension.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 ){
+        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;
@@ -580 +586 @@
 }
 
-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 );
+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->packet_dimension.content = mtu;
-        printf( "ip - device %d changed mtu to %d\n\n", device_id, mtu );
-        fibril_rwlock_write_unlock( & ip_globals.netifs_lock );
+        printf("ip - device %d changed mtu to %d\n\n", device_id, mtu);
+        fibril_rwlock_write_unlock(&ip_globals.netifs_lock);
         return EOK;
 }
 
-int ip_device_state_message( device_id_t device_id, device_state_t state ){
-        ip_netif_ref    netif;
-
-        fibril_rwlock_write_lock( & ip_globals.netifs_lock );
+int ip_device_state_message(device_id_t device_id, device_state_t state){
+        ip_netif_ref netif;
+
+        fibril_rwlock_write_lock(&ip_globals.netifs_lock);
         // find the device
-        netif = ip_netifs_find( & ip_globals.netifs, device_id );
-        if( ! netif ){
-                fibril_rwlock_write_unlock( & ip_globals.netifs_lock );
+        netif = ip_netifs_find(&ip_globals.netifs, device_id);
+        if(! netif){
+                fibril_rwlock_write_unlock(&ip_globals.netifs_lock);
                 return ENOENT;
         }
         netif->state = state;
-        printf( "ip - device %d changed state to %d\n\n", device_id, state );
-        fibril_rwlock_write_unlock( & ip_globals.netifs_lock );
+        printf("ip - device %d changed state to %d\n\n", device_id, state);
+        fibril_rwlock_write_unlock(&ip_globals.netifs_lock);
         return EOK;
 }
 
-int ip_connect_module( services_t service ){
+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;
+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 );
+        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 );
+        printf("New protocol registered:\n\tprotocol\t= %d\n\tphone\t= %d\n", proto->protocol, proto->phone);
+        fibril_rwlock_write_unlock(&ip_globals.protos_lock);
         return EOK;
 }
 
-int ip_send_msg( int il_phone, device_id_t device_id, packet_t packet, services_t sender, services_t error ){
+int ip_send_msg(int il_phone, device_id_t device_id, packet_t packet, services_t sender, services_t error){
         ERROR_DECLARE;
 
-        int                                     addrlen;
-        ip_netif_ref            netif;
-        ip_route_ref            route;
-        struct sockaddr *               addr;
-        struct sockaddr_in *    address_in;
+        int addrlen;
+        ip_netif_ref netif;
+        ip_route_ref route;
+        struct sockaddr * addr;
+        struct sockaddr_in * address_in;
 //      struct sockaddr_in6 *   address_in6;
-        in_addr_t *                     dest;
-        in_addr_t *                     src;
-        int                                     phone;
+        in_addr_t * dest;
+        in_addr_t * src;
+        int phone;
 
         // addresses in the host byte order
         // should be the next hop address or the target destination address
-        addrlen = packet_get_addr( packet, NULL, ( uint8_t ** ) & addr );
-        if( addrlen < 0 ){
-                return ip_release_and_return( packet, addrlen );
-        }
-        if(( size_t ) addrlen < sizeof( struct sockaddr )){
-                return ip_release_and_return( packet, EINVAL );
-        }
-        switch( addr->sa_family ){
+        addrlen = packet_get_addr(packet, NULL, (uint8_t **) &addr);
+        if(addrlen < 0){
+                return ip_release_and_return(packet, addrlen);
+        }
+        if((size_t) addrlen < sizeof(struct sockaddr)){
+                return ip_release_and_return(packet, EINVAL);
+        }
+        switch(addr->sa_family){
                 case AF_INET:
-                        if( addrlen != sizeof( struct sockaddr_in )){
-                                return ip_release_and_return( packet, EINVAL );
-                        }
-                        address_in = ( struct sockaddr_in * ) addr;
-                        dest = & address_in->sin_addr;
-                        if( ! dest->s_addr ){
+                        if(addrlen != sizeof(struct sockaddr_in)){
+                                return ip_release_and_return(packet, EINVAL);
+                        }
+                        address_in = (struct sockaddr_in *) addr;
+                        dest = &address_in->sin_addr;
+                        if(! dest->s_addr){
                                 dest->s_addr = IPV4_LOCALHOST_ADDRESS;
                         }
@@ -677 +687 @@
                 // TODO IPv6
 /*              case AF_INET6:
-                        if( addrlen != sizeof( struct sockaddr_in6 )) return EINVAL;
-                        address_in6 = ( struct sockaddr_in6 * ) dest;
+                        if(addrlen != sizeof(struct sockaddr_in6)){
+                                return EINVAL;
+                        }
+                        address_in6 = (struct sockaddr_in6 *) dest;
                         address_in6.sin6_addr.s6_addr;
                         IPV6_LOCALHOST_ADDRESS;
 */              default:
-                        return ip_release_and_return( packet, EAFNOSUPPORT );
-        }
-        fibril_rwlock_read_lock( & ip_globals.netifs_lock );
+                        return ip_release_and_return(packet, EAFNOSUPPORT);
+        }
+        fibril_rwlock_read_lock(&ip_globals.netifs_lock);
         // device specified?
-        if( device_id > 0 ){
-                netif = ip_netifs_find( & ip_globals.netifs, device_id );
-                route = ip_netif_find_route( netif, * dest );
-                if( netif && ( ! route ) && ( ip_globals.gateway.netif == netif )){
-                        route = & ip_globals.gateway;
+        if(device_id > 0){
+                netif = ip_netifs_find(&ip_globals.netifs, device_id);
+                route = ip_netif_find_route(netif, * dest);
+                if(netif && (! route) && (ip_globals.gateway.netif == netif)){
+                        route = &ip_globals.gateway;
                 }
         }else{
-                route = ip_find_route( * dest );
+                route = ip_find_route(*dest);
                 netif = route ? route->netif : NULL;
         }
-        if( !( netif && route )){
-                fibril_rwlock_read_unlock( & ip_globals.netifs_lock );
-                phone = ip_prepare_icmp_and_get_phone( error, packet, NULL );
-                if( phone >= 0 ){
+        if(!(netif && route)){
+                fibril_rwlock_read_unlock(&ip_globals.netifs_lock);
+                phone = ip_prepare_icmp_and_get_phone(error, packet, NULL);
+                if(phone >= 0){
                         // unreachable ICMP if no routing
-                        icmp_destination_unreachable_msg( phone, ICMP_NET_UNREACH, 0, packet );
+                        icmp_destination_unreachable_msg(phone, ICMP_NET_UNREACH, 0, packet);
                 }
                 return ENOENT;
         }
-        if( error ){
+        if(error){
                 // do not send for broadcast, anycast packets or network broadcast
-                if(( ! dest->s_addr )
-                || ( !( ~ dest->s_addr ))
-                || ( !( ~(( dest->s_addr & ( ~ route->netmask.s_addr )) | route->netmask.s_addr )))
-                || ( !( dest->s_addr & ( ~ route->netmask.s_addr )))){
-                        return ip_release_and_return( packet, EINVAL );
-                }
-        }
-        if( route->address.s_addr == dest->s_addr ){
+                if((! dest->s_addr)
+                        || (!(~ dest->s_addr))
+                        || (!(~((dest->s_addr &(~ route->netmask.s_addr)) | route->netmask.s_addr)))
+                        || (!(dest->s_addr &(~ route->netmask.s_addr)))){
+                        return ip_release_and_return(packet, EINVAL);
+                }
+        }
+        if(route->address.s_addr == dest->s_addr){
                 // find the loopback device to deliver
                 dest->s_addr = IPV4_LOCALHOST_ADDRESS;
-                route = ip_find_route( * dest );
+                route = ip_find_route(*dest);
                 netif = route ? route->netif : NULL;
-                if( !( netif && route )){
-                        fibril_rwlock_read_unlock( & ip_globals.netifs_lock );
-                        phone = ip_prepare_icmp_and_get_phone( error, packet, NULL );
-                        if( phone >= 0 ){
+                if(!(netif && route)){
+                        fibril_rwlock_read_unlock(&ip_globals.netifs_lock);
+                        phone = ip_prepare_icmp_and_get_phone(error, packet, NULL);
+                        if(phone >= 0){
                                 // unreachable ICMP if no routing
-                                icmp_destination_unreachable_msg( phone, ICMP_HOST_UNREACH, 0, packet );
+                                icmp_destination_unreachable_msg(phone, ICMP_HOST_UNREACH, 0, packet);
                         }
                         return ENOENT;
                 }
         }
-        src = ip_netif_address( netif );
-        if( ! src ){
-                fibril_rwlock_read_unlock( & ip_globals.netifs_lock );
-                return ip_release_and_return( packet, ENOENT );
-        }
-        ERROR_CODE = ip_send_route( packet, netif, route, src, * dest, error );
-        fibril_rwlock_read_unlock( & ip_globals.netifs_lock );
+        src = ip_netif_address(netif);
+        if(! src){
+                fibril_rwlock_read_unlock(&ip_globals.netifs_lock);
+                return ip_release_and_return(packet, ENOENT);
+        }
+        ERROR_CODE = ip_send_route(packet, netif, route, src, * dest, error);
+        fibril_rwlock_read_unlock(&ip_globals.netifs_lock);
         return ERROR_CODE;
 }
 
-in_addr_t * ip_netif_address( ip_netif_ref netif ){
-        ip_route_ref    route;
-
-        route = ip_routes_get_index( & netif->routes, 0 );
-        return route ? & route->address : NULL;
-}
-
-int ip_send_route( packet_t packet, ip_netif_ref netif, ip_route_ref route, in_addr_t * src, in_addr_t dest, services_t error ){
+in_addr_t * ip_netif_address(ip_netif_ref netif){
+        ip_route_ref route;
+
+        route = ip_routes_get_index(&netif->routes, 0);
+        return route ? &route->address : NULL;
+}
+
+int ip_send_route(packet_t packet, ip_netif_ref netif, ip_route_ref route, in_addr_t * src, in_addr_t dest, services_t error){
         ERROR_DECLARE;
 
-        measured_string_t       destination;
-        measured_string_ref     translation;
-        char *                          data;
-        int                                     phone;
+        measured_string_t destination;
+        measured_string_ref translation;
+        char * data;
+        int phone;
 
         // get destination hardware address
-        if( netif->arp && ( route->address.s_addr != dest.s_addr )){
-                destination.value = route->gateway.s_addr ? ( char * ) & route->gateway.s_addr : ( char * ) & dest.s_addr;
-                destination.length = CONVERT_SIZE( dest.s_addr, char, 1 );
-                if( ERROR_OCCURRED( arp_translate_req( netif->arp->phone, netif->device_id, SERVICE_IP, & destination, & translation, & data ))){
-//                      sleep( 1 );
-//                      ERROR_PROPAGATE( arp_translate_req( netif->arp->phone, netif->device_id, SERVICE_IP, & destination, & translation, & data ));
-                        pq_release( ip_globals.net_phone, packet_get_id( packet ));
+        if(netif->arp && (route->address.s_addr != dest.s_addr)){
+                destination.value = route->gateway.s_addr ? (char *) &route->gateway.s_addr : (char *) &dest.s_addr;
+                destination.length = CONVERT_SIZE(dest.s_addr, char, 1);
+                if(ERROR_OCCURRED(arp_translate_req(netif->arp->phone, netif->device_id, SERVICE_IP, &destination, &translation, &data))){
+//                      sleep(1);
+//                      ERROR_PROPAGATE(arp_translate_req(netif->arp->phone, netif->device_id, SERVICE_IP, &destination, &translation, &data));
+                        pq_release(ip_globals.net_phone, packet_get_id(packet));
                         return ERROR_CODE;
                 }
-                if( !( translation && translation->value )){
-                        if( translation ){
-                                free( translation );
-                                free( data );
-                        }
-                        phone = ip_prepare_icmp_and_get_phone( error, packet, NULL );
-                        if( phone >= 0 ){
+                if(!(translation && translation->value)){
+                        if(translation){
+                                free(translation);
+                                free(data);
+                        }
+                        phone = ip_prepare_icmp_and_get_phone(error, packet, NULL);
+                        if(phone >= 0){
                                 // unreachable ICMP if no routing
-                                icmp_destination_unreachable_msg( phone, ICMP_HOST_UNREACH, 0, packet );
+                                icmp_destination_unreachable_msg(phone, ICMP_HOST_UNREACH, 0, packet);
                         }
                         return EINVAL;
                 }
         }else translation = NULL;
-        if( ERROR_OCCURRED( ip_prepare_packet( src, dest, packet, translation ))){
-                pq_release( ip_globals.net_phone, packet_get_id( packet ));
+        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->packet_dimension.prefix, netif->packet_dimension.content, netif->packet_dimension.suffix, netif->packet_dimension.addr_len, error );
-                if( packet ){
-                        nil_send_msg( netif->phone, netif->device_id, packet, SERVICE_IP );
-                }
-        }
-        if( translation ){
-                free( translation );
-                free( data );
+                packet = ip_split_packet(packet, netif->packet_dimension.prefix, netif->packet_dimension.content, netif->packet_dimension.suffix, netif->packet_dimension.addr_len, error);
+                if(packet){
+                        nil_send_msg(netif->phone, netif->device_id, packet, SERVICE_IP);
+                }
+        }
+        if(translation){
+                free(translation);
+                free(data);
         }
         return ERROR_CODE;
 }
 
-int ip_prepare_packet( in_addr_t * source, in_addr_t dest, packet_t packet, measured_string_ref destination ){
+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 )));
+        size_t length;
+        ip_header_ref header;
+        ip_header_ref last_header;
+        ip_header_ref middle_header;
+        packet_t next;
+
+        length = packet_get_data_length(packet);
+        if((length < sizeof(ip_header_t)) || (length > IP_MAX_CONTENT)){
+                return EINVAL;
+        }
+        header = (ip_header_ref) packet_get_data(packet);
+        if(destination){
+                ERROR_PROPAGATE(packet_set_addr(packet, NULL, (uint8_t *) destination->value, CONVERT_SIZE(char, uint8_t, destination->length)));
         }else{
-                ERROR_PROPAGATE( packet_set_addr( packet, NULL, NULL, 0 ));
+                ERROR_PROPAGATE(packet_set_addr(packet, NULL, NULL, 0));
         }
         header->version = IPV4;
@@ -813 +827 @@
         header->fragment_offset_low = 0;
         header->header_checksum = 0;
-        if( source ) header->source_address = source->s_addr;
+        if(source){
+                header->source_address = source->s_addr;
+        }
         header->destination_address = dest.s_addr;
-        fibril_rwlock_write_lock( & ip_globals.lock );
+        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->identification = htons(ip_globals.packet_counter);
+        fibril_rwlock_write_unlock(&ip_globals.lock);
+//      length = packet_get_data_length(packet);
+        if(pq_next(packet)){
+                last_header = (ip_header_ref) malloc(IP_HEADER_LENGTH(header));
+                if(! last_header){
+                        return ENOMEM;
+                }
+                ip_create_last_header(last_header, header);
+                next = pq_next(packet);
+                while(pq_next(next)){
+                        middle_header = (ip_header_ref) packet_prefix(next, IP_HEADER_LENGTH(last_header));
+                        if(! middle_header){
+                                return ENOMEM;
+                        }
+                        memcpy(middle_header, last_header, IP_HEADER_LENGTH(last_header));
                         header->flags |= IPFLAG_MORE_FRAGMENTS;
-                        middle_header->total_length = htons( packet_get_data_length( next ));
-                        middle_header->fragment_offset_high = IP_COMPUTE_FRAGMENT_OFFSET_HIGH( length );
-                        middle_header->fragment_offset_low = IP_COMPUTE_FRAGMENT_OFFSET_LOW( length );
-                        middle_header->header_checksum = IP_HEADER_CHECKSUM( middle_header );
-                        if( destination ){
-                                ERROR_PROPAGATE( packet_set_addr( next, NULL, ( uint8_t * ) destination->value, CONVERT_SIZE( char, uint8_t, destination->length )));
-                        }
-                        length += packet_get_data_length( next );
-                        next = pq_next( next );
-                }
-                middle_header = ( ip_header_ref ) packet_prefix( next, IP_HEADER_LENGTH( last_header ));
-                if( ! middle_header ) return ENOMEM;
-                memcpy( middle_header, last_header, IP_HEADER_LENGTH( last_header ));
-                middle_header->total_length = htons( packet_get_data_length( next ));
-                middle_header->fragment_offset_high = IP_COMPUTE_FRAGMENT_OFFSET_HIGH( length );
-                middle_header->fragment_offset_low = IP_COMPUTE_FRAGMENT_OFFSET_LOW( length );
-                middle_header->header_checksum = IP_HEADER_CHECKSUM( middle_header );
-                if( destination ){
-                        ERROR_PROPAGATE( packet_set_addr( next, NULL, ( uint8_t * ) destination->value, CONVERT_SIZE( char, uint8_t, destination->length )));
-                }
-                length += packet_get_data_length( next );
-                free( last_header );
+                        middle_header->total_length = htons(packet_get_data_length(next));
+                        middle_header->fragment_offset_high = IP_COMPUTE_FRAGMENT_OFFSET_HIGH(length);
+                        middle_header->fragment_offset_low = IP_COMPUTE_FRAGMENT_OFFSET_LOW(length);
+                        middle_header->header_checksum = IP_HEADER_CHECKSUM(middle_header);
+                        if(destination){
+                                ERROR_PROPAGATE(packet_set_addr(next, NULL, (uint8_t *) destination->value, CONVERT_SIZE(char, uint8_t, destination->length)));
+                        }
+                        length += packet_get_data_length(next);
+                        next = pq_next(next);
+                }
+                middle_header = (ip_header_ref) packet_prefix(next, IP_HEADER_LENGTH(last_header));
+                if(! middle_header){
+                        return ENOMEM;
+                }
+                memcpy(middle_header, last_header, IP_HEADER_LENGTH(last_header));
+                middle_header->total_length = htons(packet_get_data_length(next));
+                middle_header->fragment_offset_high = IP_COMPUTE_FRAGMENT_OFFSET_HIGH(length);
+                middle_header->fragment_offset_low = IP_COMPUTE_FRAGMENT_OFFSET_LOW(length);
+                middle_header->header_checksum = IP_HEADER_CHECKSUM(middle_header);
+                if(destination){
+                        ERROR_PROPAGATE(packet_set_addr(next, NULL, (uint8_t *) destination->value, CONVERT_SIZE(char, uint8_t, destination->length)));
+                }
+                length += packet_get_data_length(next);
+                free(last_header);
                 header->flags |= IPFLAG_MORE_FRAGMENTS;
         }
-        header->total_length = htons( length );
+        header->total_length = htons(length);
         // unnecessary for all protocols
-        header->header_checksum = IP_HEADER_CHECKSUM( header );
+        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 ){
+int ip_message(ipc_callid_t callid, ipc_call_t * call, ipc_call_t * answer, int * answer_count){
         ERROR_DECLARE;
 
-        packet_t                                packet;
-        struct sockaddr *               addr;
-        size_t                                  addrlen;
-        ip_pseudo_header_ref    header;
-        size_t                                  headerlen;
-
-        * answer_count = 0;
-        switch( IPC_GET_METHOD( * call )){
+        packet_t packet;
+        struct sockaddr * addr;
+        size_t addrlen;
+        ip_pseudo_header_ref header;
+        size_t headerlen;
+
+        *answer_count = 0;
+        switch(IPC_GET_METHOD(*call)){
                 case IPC_M_PHONE_HUNGUP:
                         return EOK;
                 case NET_IL_DEVICE:
-                        return ip_device_req( 0, IPC_GET_DEVICE( call ), IPC_GET_SERVICE( call ));
+                        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 );
+                        return ip_register(IL_GET_PROTO(call), IL_GET_SERVICE(call), IPC_GET_PHONE(call), NULL);
                 case NET_IL_SEND:
-                        ERROR_PROPAGATE( packet_translate( ip_globals.net_phone, & packet, IPC_GET_PACKET( call )));
-                        return ip_send_msg( 0, IPC_GET_DEVICE( call ), packet, 0, IPC_GET_ERROR( call ));
+                        ERROR_PROPAGATE(packet_translate(ip_globals.net_phone, &packet, IPC_GET_PACKET(call)));
+                        return ip_send_msg(0, IPC_GET_DEVICE(call), packet, 0, IPC_GET_ERROR(call));
                 case NET_IL_DEVICE_STATE:
-                        return ip_device_state_message( IPC_GET_DEVICE( call ), IPC_GET_STATE( call ));
+                        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 );
+                        ERROR_PROPAGATE(packet_translate(ip_globals.net_phone, &packet, IPC_GET_PACKET(call)));
+                        return ip_receive_message(IPC_GET_DEVICE(call), packet);
                 case NET_IP_RECEIVED_ERROR:
-                        ERROR_PROPAGATE( packet_translate( ip_globals.net_phone, & packet, IPC_GET_PACKET( call )));
-                        return ip_received_error_msg( 0, IPC_GET_DEVICE( call ), packet, IPC_GET_TARGET( call ), IPC_GET_ERROR( call ));
+                        ERROR_PROPAGATE(packet_translate(ip_globals.net_phone, &packet, IPC_GET_PACKET(call)));
+                        return ip_received_error_msg(0, IPC_GET_DEVICE(call), packet, IPC_GET_TARGET(call), IPC_GET_ERROR(call));
                 case NET_IP_ADD_ROUTE:
-                        return ip_add_route_req( 0, IPC_GET_DEVICE( call ), IP_GET_ADDRESS( call ), IP_GET_NETMASK( call ), IP_GET_GATEWAY( call ));
+                        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 ));
+                        return ip_set_gateway_req(0, IPC_GET_DEVICE(call), IP_GET_GATEWAY(call));
                 case NET_IP_GET_ROUTE:
-                        ERROR_PROPAGATE( data_receive(( void ** ) & addr, & addrlen ));
-                        ERROR_PROPAGATE( ip_get_route_req( 0, IP_GET_PROTOCOL( call ), addr, ( socklen_t ) addrlen, IPC_SET_DEVICE( answer ), & header, & headerlen ));
-                        * IP_SET_HEADERLEN( answer ) = headerlen;
-                        * answer_count = 2;
-                        if( ! ERROR_OCCURRED( data_reply( & headerlen, sizeof( headerlen )))){
-                                ERROR_CODE = data_reply( header, headerlen );
-                        }
-                        free( header );
+                        ERROR_PROPAGATE(data_receive((void **) &addr, &addrlen));
+                        ERROR_PROPAGATE(ip_get_route_req(0, IP_GET_PROTOCOL(call), addr, (socklen_t) addrlen, IPC_SET_DEVICE(answer), &header, &headerlen));
+                        *IP_SET_HEADERLEN(answer) = headerlen;
+                        *answer_count = 2;
+                        if(! ERROR_OCCURRED(data_reply(&headerlen, sizeof(headerlen)))){
+                                ERROR_CODE = data_reply(header, headerlen);
+                        }
+                        free(header);
                         return ERROR_CODE;
                 case NET_IL_PACKET_SPACE:
-                        ERROR_PROPAGATE( ip_packet_size_message( IPC_GET_DEVICE( call ), IPC_SET_ADDR( answer ), IPC_SET_PREFIX( answer ), IPC_SET_CONTENT( answer ), IPC_SET_SUFFIX( answer )));
-                        * answer_count = 3;
+                        ERROR_PROPAGATE(ip_packet_size_message(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 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, packet_dimension_ref packet_dimension ){
-        if( ! packet_dimension ) return EBADMEM;
-        return ip_packet_size_message( device_id, & packet_dimension->addr_len, & packet_dimension->prefix, & packet_dimension->content, & packet_dimension->suffix );
-}
-
-int ip_packet_size_message( 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->packet_dimension.addr_len > * addr_len ) * addr_len = netif->packet_dimension.addr_len;
-                                if( netif->packet_dimension.prefix > * prefix ) * prefix = netif->packet_dimension.prefix;
-                                if( netif->packet_dimension.suffix > * suffix ) * suffix = netif->packet_dimension.suffix;
-                        }
-                }
-                * prefix = * prefix + IP_PREFIX;
-                * suffix = * suffix + IP_SUFFIX;
+int ip_packet_size_req(int ip_phone, device_id_t device_id, packet_dimension_ref packet_dimension){
+        if(! packet_dimension){
+                return EBADMEM;
+        }
+        return ip_packet_size_message(device_id, &packet_dimension->addr_len, &packet_dimension->prefix, &packet_dimension->content, &packet_dimension->suffix);
+}
+
+int ip_packet_size_message(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->packet_dimension.addr_len > * addr_len){
+                                        *addr_len = netif->packet_dimension.addr_len;
+                                }
+                                if(netif->packet_dimension.prefix > * prefix){
+                                        *prefix = netif->packet_dimension.prefix;
+                                }
+                                if(netif->packet_dimension.suffix > * suffix){
+                                        *suffix = netif->packet_dimension.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 );
+                netif = ip_netifs_find(&ip_globals.netifs, device_id);
+                if(! netif){
+                        fibril_rwlock_read_unlock(&ip_globals.netifs_lock);
                         return ENOENT;
                 }
-                * addr_len = ( netif->packet_dimension.addr_len > IP_ADDR ) ? netif->packet_dimension.addr_len : IP_ADDR;
-                * prefix = netif->packet_dimension.prefix + IP_PREFIX;
-                * suffix = netif->packet_dimension.suffix + IP_SUFFIX;
-        }
-        fibril_rwlock_read_unlock( & ip_globals.netifs_lock );
+                *addr_len = (netif->packet_dimension.addr_len > IP_ADDR) ? netif->packet_dimension.addr_len : IP_ADDR;
+                *prefix = netif->packet_dimension.prefix + IP_PREFIX;
+                *suffix = netif->packet_dimension.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 );
+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 );
+        route = (ip_route_ref) malloc(sizeof(ip_route_t));
+        if(! route){
+                fibril_rwlock_write_unlock(&ip_globals.netifs_lock);
                 return ENOMEM;
         }
@@ -972 +1004 @@
         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 );
+        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;
+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 = 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 ){
+        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 ))){
+                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;
                         }
@@ -1012 +1048 @@
 }
 
-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 );
+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;
         }
@@ -1025 +1061 @@
         ip_globals.gateway.gateway.s_addr = gateway.s_addr;
         ip_globals.gateway.netif = netif;
-        fibril_rwlock_write_unlock( & ip_globals.netifs_lock );
+        fibril_rwlock_write_unlock(&ip_globals.netifs_lock);
         return EOK;
 }
 
-packet_t ip_split_packet( packet_t packet, size_t prefix, size_t content, size_t suffix, socklen_t addr_len, services_t error ){
-        size_t                  length;
-        packet_t                next;
-        packet_t                new_packet;
-        int                             result;
-        int                             phone;
+packet_t ip_split_packet(packet_t packet, size_t prefix, size_t content, size_t suffix, socklen_t addr_len, services_t error){
+        size_t length;
+        packet_t next;
+        packet_t new_packet;
+        int result;
+        int phone;
 
         next = packet;
         // check all packets
-        while( next ){
-                length = packet_get_data_length( next );
+        while(next){
+                length = packet_get_data_length(next);
                 // too long?
-                if( length > content ){
-                        result = ip_fragment_packet( next, content, prefix, suffix, addr_len );
-                        if( result != EOK ){
-                                new_packet = pq_detach( next );
-                                if( next == packet ){
+                if(length > content){
+                        result = ip_fragment_packet(next, content, prefix, suffix, addr_len);
+                        if(result != EOK){
+                                new_packet = pq_detach(next);
+                                if(next == packet){
                                         // the new first packet of the queue
                                         packet = new_packet;
                                 }
                                 // fragmentation needed?
-                                if( result == EPERM ){
-                                        phone = ip_prepare_icmp_and_get_phone( error, next, NULL );
-                                        if( phone >= 0 ){
+                                if(result == EPERM){
+                                        phone = ip_prepare_icmp_and_get_phone(error, next, NULL);
+                                        if(phone >= 0){
                                                 // fragmentation necessary ICMP
-                                                icmp_destination_unreachable_msg( phone, ICMP_FRAG_NEEDED, content, next );
+                                                icmp_destination_unreachable_msg(phone, ICMP_FRAG_NEEDED, content, next);
                                         }
                                 }else{
-                                        pq_release( ip_globals.net_phone, packet_get_id( next ));
+                                        pq_release(ip_globals.net_phone, packet_get_id(next));
                                 }
                                 next = new_packet;
@@ -1063 +1099 @@
                         }
                 }
-                next = pq_next( next );
+                next = pq_next(next);
         }
         return packet;
 }
 
-int ip_fragment_packet( packet_t packet, size_t length, size_t prefix, size_t suffix, socklen_t addr_len ){
+int ip_fragment_packet(packet_t packet, size_t length, size_t prefix, size_t suffix, socklen_t addr_len){
         ERROR_DECLARE;
 
-        packet_t                new_packet;
-        ip_header_ref   header;
-        ip_header_ref   middle_header;
-        ip_header_ref   last_header;
-        struct sockaddr *               src;
-        struct sockaddr *               dest;
-        socklen_t               addrlen;
-        int                             result;
-
-        result = packet_get_addr( packet, ( uint8_t ** ) & src, ( uint8_t ** ) & dest );
-        if( result <= 0 ) return EINVAL;
-        addrlen = ( socklen_t ) result;
-        if( packet_get_data_length( packet ) <= sizeof( ip_header_t )) return ENOMEM;
+        packet_t new_packet;
+        ip_header_ref header;
+        ip_header_ref middle_header;
+        ip_header_ref last_header;
+        struct sockaddr * src;
+        struct sockaddr * dest;
+        socklen_t addrlen;
+        int result;
+
+        result = packet_get_addr(packet, (uint8_t **) &src, (uint8_t **) &dest);
+        if(result <= 0){
+                return EINVAL;
+        }
+        addrlen = (socklen_t) result;
+        if(packet_get_data_length(packet) <= sizeof(ip_header_t)){
+                return ENOMEM;
+        }
         // get header
-        header = ( ip_header_ref ) packet_get_data( packet );
-        if( ! header ) return EINVAL;
+        header = (ip_header_ref) packet_get_data(packet);
+        if(! header){
+                return EINVAL;
+        }
         // fragmentation forbidden?
-        if( header->flags & IPFLAG_DONT_FRAGMENT ){
+        if(header->flags &IPFLAG_DONT_FRAGMENT){
                 return EPERM;
         }
         // create the last fragment
-        new_packet = packet_get_4( ip_globals.net_phone, prefix, length, suffix, (( addrlen > addr_len ) ? addrlen : addr_len ));
-        if( ! new_packet ) return ENOMEM;
+        new_packet = packet_get_4(ip_globals.net_phone, prefix, length, suffix, ((addrlen > addr_len) ? addrlen : addr_len));
+        if(! new_packet){
+                return ENOMEM;
+        }
         // allocate as much as originally
-        last_header = ( ip_header_ref ) packet_suffix( new_packet, IP_HEADER_LENGTH( header ));
-        if( ! last_header ){
-                return ip_release_and_return( packet, ENOMEM );
-        }
-        ip_create_last_header( last_header, header );
+        last_header = (ip_header_ref) packet_suffix(new_packet, IP_HEADER_LENGTH(header));
+        if(! last_header){
+                return ip_release_and_return(packet, ENOMEM);
+        }
+        ip_create_last_header(last_header, header);
         // trim the unused space
-        if( ERROR_OCCURRED( packet_trim( new_packet, 0, IP_HEADER_LENGTH( header ) - IP_HEADER_LENGTH( last_header )))){
-                return ip_release_and_return( packet, ERROR_CODE );
+        if(ERROR_OCCURRED(packet_trim(new_packet, 0, IP_HEADER_LENGTH(header) - IP_HEADER_LENGTH(last_header)))){
+                return ip_release_and_return(packet, ERROR_CODE);
         }
         // biggest multiple of 8 lower than content
         // TODO even fragmentation?
-        length = length & ( ~ 0x7 );// ( content / 8 ) * 8
-        if( ERROR_OCCURRED( ip_fragment_packet_data( packet, new_packet, header, last_header, (( IP_HEADER_DATA_LENGTH( header ) - (( length - IP_HEADER_LENGTH( header )) & ( ~ 0x7 ))) % (( length - IP_HEADER_LENGTH( last_header )) & ( ~ 0x7 ))), src, dest, addrlen ))){
-                return ip_release_and_return( packet, ERROR_CODE );
+        length = length &(~ 0x7);// (content / 8) * 8
+        if(ERROR_OCCURRED(ip_fragment_packet_data(packet, new_packet, header, last_header, ((IP_HEADER_DATA_LENGTH(header) - ((length - IP_HEADER_LENGTH(header)) &(~ 0x7))) % ((length - IP_HEADER_LENGTH(last_header)) &(~ 0x7))), src, dest, addrlen))){
+                return ip_release_and_return(packet, ERROR_CODE);
         }
         // mark the first as fragmented
         header->flags |= IPFLAG_MORE_FRAGMENTS;
         // create middle framgents
-        while( IP_TOTAL_LENGTH( header ) > length ){
-                new_packet = packet_get_4( ip_globals.net_phone, prefix, length, suffix, (( addrlen >= addr_len ) ? addrlen : addr_len ));
-                if( ! new_packet ) return ENOMEM;
-                middle_header = ip_create_middle_header( new_packet, last_header );
-                if( ! middle_header ){
-                        return ip_release_and_return( packet, ENOMEM );
-                }
-                if( ERROR_OCCURRED( ip_fragment_packet_data( packet, new_packet, header, middle_header, ( length - IP_HEADER_LENGTH( middle_header )) & ( ~ 0x7 ), src, dest, addrlen ))){
-                        return ip_release_and_return( packet, ERROR_CODE );
+        while(IP_TOTAL_LENGTH(header) > length){
+                new_packet = packet_get_4(ip_globals.net_phone, prefix, length, suffix, ((addrlen >= addr_len) ? addrlen : addr_len));
+                if(! new_packet){
+                        return ENOMEM;
+                }
+                middle_header = ip_create_middle_header(new_packet, last_header);
+                if(! middle_header){
+                        return ip_release_and_return(packet, ENOMEM);
+                }
+                if(ERROR_OCCURRED(ip_fragment_packet_data(packet, new_packet, header, middle_header, (length - IP_HEADER_LENGTH(middle_header)) &(~ 0x7), src, dest, addrlen))){
+                        return ip_release_and_return(packet, ERROR_CODE);
                 }
         }
         // finish the first fragment
-        header->header_checksum = IP_HEADER_CHECKSUM( header );
+        header->header_checksum = IP_HEADER_CHECKSUM(header);
         return EOK;
 }
 
-int ip_fragment_packet_data( packet_t packet, packet_t new_packet, ip_header_ref header, ip_header_ref new_header, size_t length, const struct sockaddr * src, const struct sockaddr * dest, socklen_t addrlen ){
+int ip_fragment_packet_data(packet_t packet, packet_t new_packet, ip_header_ref header, ip_header_ref new_header, size_t length, const struct sockaddr * src, const struct sockaddr * dest, socklen_t addrlen){
         ERROR_DECLARE;
 
-        void *                  data;
-        size_t                  offset;
-
-        data = packet_suffix( new_packet, length );
-        if( ! data ) return ENOMEM;
-        memcpy( data, (( void * ) header ) + IP_TOTAL_LENGTH( header ) - length, length );
-        ERROR_PROPAGATE( packet_trim( packet, 0, length ));
-        header->total_length = htons( IP_TOTAL_LENGTH( header ) - length );
-        new_header->total_length = htons( IP_HEADER_LENGTH( new_header ) + length );
-        offset = IP_FRAGMENT_OFFSET( header ) + IP_HEADER_DATA_LENGTH( header );
-        new_header->fragment_offset_high = IP_COMPUTE_FRAGMENT_OFFSET_HIGH( offset );
-        new_header->fragment_offset_low = IP_COMPUTE_FRAGMENT_OFFSET_LOW( offset );
-        new_header->header_checksum = IP_HEADER_CHECKSUM( new_header );
-        ERROR_PROPAGATE( packet_set_addr( new_packet, ( const uint8_t * ) src, ( const uint8_t * ) dest, addrlen ));
-        return pq_insert_after( packet, new_packet );
-}
-
-ip_header_ref ip_create_middle_header( packet_t packet, ip_header_ref last ){
-        ip_header_ref   middle;
-
-        middle = ( ip_header_ref ) packet_suffix( packet, IP_HEADER_LENGTH( last ));
-        if( ! middle ) return NULL;
-        memcpy( middle, last, IP_HEADER_LENGTH( last ));
+        void * data;
+        size_t offset;
+
+        data = packet_suffix(new_packet, length);
+        if(! data){
+                return ENOMEM;
+        }
+        memcpy(data, ((void *) header) + IP_TOTAL_LENGTH(header) - length, length);
+        ERROR_PROPAGATE(packet_trim(packet, 0, length));
+        header->total_length = htons(IP_TOTAL_LENGTH(header) - length);
+        new_header->total_length = htons(IP_HEADER_LENGTH(new_header) + length);
+        offset = IP_FRAGMENT_OFFSET(header) + IP_HEADER_DATA_LENGTH(header);
+        new_header->fragment_offset_high = IP_COMPUTE_FRAGMENT_OFFSET_HIGH(offset);
+        new_header->fragment_offset_low = IP_COMPUTE_FRAGMENT_OFFSET_LOW(offset);
+        new_header->header_checksum = IP_HEADER_CHECKSUM(new_header);
+        ERROR_PROPAGATE(packet_set_addr(new_packet, (const uint8_t *) src, (const uint8_t *) dest, addrlen));
+        return pq_insert_after(packet, new_packet);
+}
+
+ip_header_ref ip_create_middle_header(packet_t packet, ip_header_ref last){
+        ip_header_ref middle;
+
+        middle = (ip_header_ref) packet_suffix(packet, IP_HEADER_LENGTH(last));
+        if(! middle){
+                return NULL;
+        }
+        memcpy(middle, last, IP_HEADER_LENGTH(last));
         middle->flags |= IPFLAG_MORE_FRAGMENTS;
         return middle;
 }
 
-void ip_create_last_header( ip_header_ref last, ip_header_ref first ){
-        ip_option_ref   option;
-        size_t                  next;
-        size_t                  length;
+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 );
+        memcpy(last, first, sizeof(ip_header_t));
+        length = sizeof(ip_header_t);
+        next = sizeof(ip_header_t);
         // process all ip options
-        while( next < first->header_length ){
-                option = ( ip_option_ref ) ((( uint8_t * ) first ) + next );
+        while(next < first->header_length){
+                option = (ip_option_ref) (((uint8_t *) first) + next);
                 // skip end or noop
-                if(( option->type == IPOPT_END ) || ( option->type == IPOPT_NOOP )){
+                if((option->type == IPOPT_END) || (option->type == IPOPT_NOOP)){
                         ++ next;
                 }else{
                         // copy if said so or skip
-                        if( IPOPT_COPIED( option->type )){
-                                memcpy((( uint8_t * ) last ) + length, (( uint8_t * ) first ) + next, option->length );
+                        if(IPOPT_COPIED(option->type)){
+                                memcpy(((uint8_t *) last) + length, ((uint8_t *) first) + next, option->length);
                                 length += option->length;
                         }
@@ -1185 +1235 @@
         }
         // align 4 byte boundary
-        if( length % 4 ){
-                bzero((( uint8_t * ) last ) + length, 4 - ( length % 4 ));
+        if(length % 4){
+                bzero(((uint8_t *) last) + length, 4 - (length % 4));
                 last->header_length = length / 4 + 1;
         }else{
@@ -1194 +1244 @@
 }
 
-int ip_receive_message( device_id_t device_id, packet_t packet ){
-        packet_t                next;
+int ip_receive_message(device_id_t device_id, packet_t packet){
+        packet_t next;
 
         do{
-                next = pq_detach( packet );
-                ip_process_packet( device_id, packet );
+                next = pq_detach(packet);
+                ip_process_packet(device_id, packet);
                 packet = next;
-        }while( packet );
+        }while(packet);
         return EOK;
 }
 
-int ip_process_packet( device_id_t device_id, packet_t packet ){
+int ip_process_packet(device_id_t device_id, packet_t packet){
         ERROR_DECLARE;
 
-        ip_header_ref   header;
-        in_addr_t               dest;
-        ip_route_ref    route;
-        int                             phone;
-        struct sockaddr *       addr;
-        struct sockaddr_in      addr_in;
+        ip_header_ref header;
+        in_addr_t dest;
+        ip_route_ref route;
+        int phone;
+        struct sockaddr * addr;
+        struct sockaddr_in addr_in;
 //      struct sockaddr_in      addr_in6;
-        socklen_t               addrlen;
-
-        header = ( ip_header_ref ) packet_get_data( packet );
-        if( ! header ){
-                return ip_release_and_return( packet, ENOMEM );
+        socklen_t addrlen;
+
+        header = (ip_header_ref) packet_get_data(packet);
+        if(! header){
+                return ip_release_and_return(packet, ENOMEM);
         }
         // checksum
-        if(( header->header_checksum ) && ( IP_HEADER_CHECKSUM( header ) != IP_CHECKSUM_ZERO )){
-                phone = ip_prepare_icmp_and_get_phone( 0, packet, header );
-                if( phone >= 0 ){
+        if((header->header_checksum) && (IP_HEADER_CHECKSUM(header) != IP_CHECKSUM_ZERO)){
+                phone = ip_prepare_icmp_and_get_phone(0, packet, header);
+                if(phone >= 0){
                         // checksum error ICMP
-                        icmp_parameter_problem_msg( phone, ICMP_PARAM_POINTER, (( size_t ) (( void * ) & header->header_checksum )) - (( size_t ) (( void * ) header )), packet );
+                        icmp_parameter_problem_msg(phone, ICMP_PARAM_POINTER, ((size_t) ((void *) &header->header_checksum)) - ((size_t) ((void *) header)), packet);
                 }
                 return EINVAL;
         }
-        if( header->ttl <= 1 ){
-                phone = ip_prepare_icmp_and_get_phone( 0, packet, header );
-                if( phone >= 0 ){
+        if(header->ttl <= 1){
+                phone = ip_prepare_icmp_and_get_phone(0, packet, header);
+                if(phone >= 0){
                         // ttl oxceeded ICMP
-                        icmp_time_exceeded_msg( phone, ICMP_EXC_TTL, packet );
+                        icmp_time_exceeded_msg(phone, ICMP_EXC_TTL, packet);
                 }
                 return EINVAL;
         }
         // process ipopt and get destination
-        dest = ip_get_destination( header );
+        dest = ip_get_destination(header);
         // set the addrination address
-        switch( header->version ){
+        switch(header->version){
                 case IPVERSION:
-                        addrlen = sizeof( addr_in );
-                        bzero( & addr_in, addrlen );
+                        addrlen = sizeof(addr_in);
+                        bzero(&addr_in, addrlen);
                         addr_in.sin_family = AF_INET;
-                        memcpy( & addr_in.sin_addr.s_addr, & dest, sizeof( dest ));
-                        addr = ( struct sockaddr * ) & addr_in;
+                        memcpy(&addr_in.sin_addr.s_addr, &dest, sizeof(dest));
+                        addr = (struct sockaddr *) &addr_in;
                         break;
 /*              case IPv6VERSION:
-                        addrlen = sizeof( dest_in6 );
-                        bzero( & dest_in6, addrlen );
+                        addrlen = sizeof(dest_in6);
+                        bzero(&dest_in6, addrlen);
                         dest_in6.sin6_family = AF_INET6;
-                        memcpy( & dest_in6.sin6_addr.s6_addr, );
-                        dest = ( struct sockaddr * ) & dest_in;
+                        memcpy(&dest_in6.sin6_addr.s6_addr,);
+                        dest = (struct sockaddr *) &dest_in;
                         break;
 */              default:
-                        return ip_release_and_return( packet, EAFNOSUPPORT );
-        }
-        ERROR_PROPAGATE( packet_set_addr( packet, NULL, ( uint8_t * ) & addr, addrlen ));
-        route = ip_find_route( dest );
-        if( ! route ){
-                phone = ip_prepare_icmp_and_get_phone( 0, packet, header );
-                if( phone >= 0 ){
+                        return ip_release_and_return(packet, EAFNOSUPPORT);
+        }
+        ERROR_PROPAGATE(packet_set_addr(packet, NULL, (uint8_t *) &addr, addrlen));
+        route = ip_find_route(dest);
+        if(! route){
+                phone = ip_prepare_icmp_and_get_phone(0, packet, header);
+                if(phone >= 0){
                         // unreachable ICMP
-                        icmp_destination_unreachable_msg( phone, ICMP_HOST_UNREACH, 0, packet );
+                        icmp_destination_unreachable_msg(phone, ICMP_HOST_UNREACH, 0, packet);
                 }
                 return ENOENT;
         }
-        if( route->address.s_addr == dest.s_addr ){
+        if(route->address.s_addr == dest.s_addr){
                 // local delivery
-                return ip_deliver_local( device_id, packet, header, 0 );
+                return ip_deliver_local(device_id, packet, header, 0);
         }else{
                 // only if routing enabled
-                if( route->netif->routing ){
+                if(route->netif->routing){
                         -- header->ttl;
-                        return ip_send_route( packet, route->netif, route, NULL, dest, 0 );
+                        return ip_send_route(packet, route->netif, route, NULL, dest, 0);
                 }else{
-                        phone = ip_prepare_icmp_and_get_phone( 0, packet, header );
-                        if( phone >= 0 ){
+                        phone = ip_prepare_icmp_and_get_phone(0, packet, header);
+                        if(phone >= 0){
                                 // unreachable ICMP if no routing
-                                icmp_destination_unreachable_msg( phone, ICMP_HOST_UNREACH, 0, packet );
+                                icmp_destination_unreachable_msg(phone, ICMP_HOST_UNREACH, 0, packet);
                         }
                         return ENOENT;
@@ -1288 +1338 @@
 }
 
-int ip_received_error_msg( int ip_phone, device_id_t device_id, packet_t packet, services_t target, services_t error ){
-        uint8_t *                       data;
-        int                                     offset;
-        icmp_type_t                     type;
-        icmp_code_t                     code;
-        ip_netif_ref            netif;
-        measured_string_t       address;
-        ip_route_ref            route;
-        ip_header_ref           header;
-
-        switch( error ){
+int ip_received_error_msg(int ip_phone, device_id_t device_id, packet_t packet, services_t target, services_t error){
+        uint8_t * data;
+        int offset;
+        icmp_type_t type;
+        icmp_code_t code;
+        ip_netif_ref netif;
+        measured_string_t address;
+        ip_route_ref route;
+        ip_header_ref header;
+
+        switch(error){
                 case SERVICE_ICMP:
-                        offset = icmp_client_process_packet( packet, & type, & code, NULL, NULL );
-                        if( offset < 0 ){
-                                return ip_release_and_return( packet, ENOMEM );
-                        }
-                        data = packet_get_data( packet );
-                        header = ( ip_header_ref )( data + offset );
+                        offset = icmp_client_process_packet(packet, &type, &code, NULL, NULL);
+                        if(offset < 0){
+                                return ip_release_and_return(packet, ENOMEM);
+                        }
+                        data = packet_get_data(packet);
+                        header = (ip_header_ref)(data + offset);
                         // destination host unreachable?
-                        if(( type == ICMP_DEST_UNREACH ) && ( code == ICMP_HOST_UNREACH )){
-                                fibril_rwlock_read_lock( & ip_globals.netifs_lock );
-                                netif = ip_netifs_find( & ip_globals.netifs, device_id );
-                                if( netif && netif->arp ){
-                                        route = ip_routes_get_index( & netif->routes, 0 );
+                        if((type == ICMP_DEST_UNREACH) && (code == ICMP_HOST_UNREACH)){
+                                fibril_rwlock_read_lock(&ip_globals.netifs_lock);
+                                netif = ip_netifs_find(&ip_globals.netifs, device_id);
+                                if(netif && netif->arp){
+                                        route = ip_routes_get_index(&netif->routes, 0);
                                         // from the same network?
-                                        if( route && (( route->address.s_addr & route->netmask.s_addr ) == ( header->destination_address & route->netmask.s_addr ))){
+                                        if(route && ((route->address.s_addr &route->netmask.s_addr) == (header->destination_address &route->netmask.s_addr))){
                                                 // clear the ARP mapping if any
-                                                address.value = ( char * ) & header->destination_address;
-                                                address.length = CONVERT_SIZE( uint8_t, char, sizeof( header->destination_address ));
-                                                arp_clear_address_req( netif->arp->phone, netif->device_id, SERVICE_IP, & address );
+                                                address.value = (char *) &header->destination_address;
+                                                address.length = CONVERT_SIZE(uint8_t, char, sizeof(header->destination_address));
+                                                arp_clear_address_req(netif->arp->phone, netif->device_id, SERVICE_IP, &address);
                                         }
                                 }
-                                fibril_rwlock_read_unlock( & ip_globals.netifs_lock );
+                                fibril_rwlock_read_unlock(&ip_globals.netifs_lock);
                         }
                         break;
                 default:
-                        return ip_release_and_return( packet, ENOTSUP );
-        }
-        return ip_deliver_local( device_id, packet, header, error );
-}
-
-int ip_deliver_local( device_id_t device_id, packet_t packet, ip_header_ref header, services_t error ){
+                        return ip_release_and_return(packet, ENOTSUP);
+        }
+        return ip_deliver_local(device_id, packet, header, error);
+}
+
+int ip_deliver_local(device_id_t device_id, packet_t packet, ip_header_ref header, services_t error){
         ERROR_DECLARE;
 
-        ip_proto_ref    proto;
-        int                             phone;
-        services_t              service;
-        tl_received_msg_t       received_msg;
-        struct sockaddr *       src;
-        struct sockaddr *       dest;
-        struct sockaddr_in      src_in;
-        struct sockaddr_in      dest_in;
+        ip_proto_ref proto;
+        int phone;
+        services_t service;
+        tl_received_msg_t received_msg;
+        struct sockaddr * src;
+        struct sockaddr * dest;
+        struct sockaddr_in src_in;
+        struct sockaddr_in dest_in;
 //      struct sockaddr_in      src_in6;
 //      struct sockaddr_in      dest_in6;
-        socklen_t               addrlen;
-
-        if(( header->flags & IPFLAG_MORE_FRAGMENTS ) || IP_FRAGMENT_OFFSET( header )){
+        socklen_t addrlen;
+
+        if((header->flags &IPFLAG_MORE_FRAGMENTS) || IP_FRAGMENT_OFFSET(header)){
                 // TODO fragmented
                 return ENOTSUP;
         }else{
-                switch( header->version ){
+                switch(header->version){
                         case IPVERSION:
-                                addrlen = sizeof( src_in );
-                                bzero( & src_in, addrlen );
+                                addrlen = sizeof(src_in);
+                                bzero(&src_in, addrlen);
                                 src_in.sin_family = AF_INET;
-                                memcpy( & dest_in, & src_in, addrlen );
-                                memcpy( & src_in.sin_addr.s_addr, & header->source_address, sizeof( header->source_address ));
-                                memcpy( & dest_in.sin_addr.s_addr, & header->destination_address, sizeof( header->destination_address ));
-                                src = ( struct sockaddr * ) & src_in;
-                                dest = ( struct sockaddr * ) & dest_in;
+                                memcpy(&dest_in, &src_in, addrlen);
+                                memcpy(&src_in.sin_addr.s_addr, &header->source_address, sizeof(header->source_address));
+                                memcpy(&dest_in.sin_addr.s_addr, &header->destination_address, sizeof(header->destination_address));
+                                src = (struct sockaddr *) &src_in;
+                                dest = (struct sockaddr *) &dest_in;
                                 break;
 /*                      case IPv6VERSION:
-                                addrlen = sizeof( src_in6 );
-                                bzero( & src_in6, addrlen );
+                                addrlen = sizeof(src_in6);
+                                bzero(&src_in6, addrlen);
                                 src_in6.sin6_family = AF_INET6;
-                                memcpy( & dest_in6, & src_in6, addrlen );
-                                memcpy( & src_in6.sin6_addr.s6_addr, );
-                                memcpy( & dest_in6.sin6_addr.s6_addr, );
-                                src = ( struct sockaddr * ) & src_in;
-                                dest = ( struct sockaddr * ) & dest_in;
+                                memcpy(&dest_in6, &src_in6, addrlen);
+                                memcpy(&src_in6.sin6_addr.s6_addr,);
+                                memcpy(&dest_in6.sin6_addr.s6_addr,);
+                                src = (struct sockaddr *) &src_in;
+                                dest = (struct sockaddr *) &dest_in;
                                 break;
 */                      default:
-                                return ip_release_and_return( packet, EAFNOSUPPORT );
-                }
-                if( ERROR_OCCURRED( packet_set_addr( packet, ( uint8_t * ) src, ( uint8_t * ) dest, addrlen ))){
-                        return ip_release_and_return( packet, ERROR_CODE );
+                                return ip_release_and_return(packet, EAFNOSUPPORT);
+                }
+                if(ERROR_OCCURRED(packet_set_addr(packet, (uint8_t *) src, (uint8_t *) dest, addrlen))){
+                        return ip_release_and_return(packet, ERROR_CODE);
                 }
                 // trim padding if present
-                if(( ! error ) && ( IP_TOTAL_LENGTH( header ) < packet_get_data_length( packet ))){
-                        if( ERROR_OCCURRED( packet_trim( packet, 0, packet_get_data_length( packet ) - IP_TOTAL_LENGTH( header )))){
-                                return ip_release_and_return( packet, ERROR_CODE );
-                        }
-                }
-                fibril_rwlock_read_lock( & ip_globals.protos_lock );
-                proto = ip_protos_find( & ip_globals.protos, header->protocol );
-                if( ! proto ){
-                        fibril_rwlock_read_unlock( & ip_globals.protos_lock );
-                        phone = ip_prepare_icmp_and_get_phone( error, packet, header );
-                        if( phone >= 0 ){
+                if((! error) && (IP_TOTAL_LENGTH(header) < packet_get_data_length(packet))){
+                        if(ERROR_OCCURRED(packet_trim(packet, 0, packet_get_data_length(packet) - IP_TOTAL_LENGTH(header)))){
+                                return ip_release_and_return(packet, ERROR_CODE);
+                        }
+                }
+                fibril_rwlock_read_lock(&ip_globals.protos_lock);
+                proto = ip_protos_find(&ip_globals.protos, header->protocol);
+                if(! proto){
+                        fibril_rwlock_read_unlock(&ip_globals.protos_lock);
+                        phone = ip_prepare_icmp_and_get_phone(error, packet, header);
+                        if(phone >= 0){
                                 // unreachable ICMP
-                                icmp_destination_unreachable_msg( phone, ICMP_PROT_UNREACH, 0, packet );
+                                icmp_destination_unreachable_msg(phone, ICMP_PROT_UNREACH, 0, packet);
                         }
                         return ENOENT;
                 }
-                if( proto->received_msg ){
+                if(proto->received_msg){
                         service = proto->service;
                         received_msg = proto->received_msg;
-                        fibril_rwlock_read_unlock( & ip_globals.protos_lock );
-                        ERROR_CODE = received_msg( device_id, packet, service, error );
+                        fibril_rwlock_read_unlock(&ip_globals.protos_lock);
+                        ERROR_CODE = received_msg(device_id, packet, service, error);
                 }else{
-                        ERROR_CODE = tl_received_msg( proto->phone, device_id, packet, proto->service, error );
-                        fibril_rwlock_read_unlock( & ip_globals.protos_lock );
+                        ERROR_CODE = tl_received_msg(proto->phone, device_id, packet, proto->service, error);
+                        fibril_rwlock_read_unlock(&ip_globals.protos_lock);
                 }
                 return ERROR_CODE;
@@ -1405 +1455 @@
 }
 
-in_addr_t ip_get_destination( ip_header_ref header ){
-        in_addr_t       destination;
+in_addr_t ip_get_destination(ip_header_ref header){
+        in_addr_t destination;
 
         // TODO search set ipopt route?
@@ -1413 +1463 @@
 }
 
-int ip_prepare_icmp( packet_t packet, ip_header_ref header ){
-        packet_t        next;
-        struct sockaddr *       dest;
-        struct sockaddr_in      dest_in;
+int ip_prepare_icmp(packet_t packet, ip_header_ref header){
+        packet_t next;
+        struct sockaddr * dest;
+        struct sockaddr_in dest_in;
 //      struct sockaddr_in      dest_in6;
-        socklen_t               addrlen;
+        socklen_t addrlen;
 
         // detach the first packet and release the others
-        next = pq_detach( packet );
-        if( next ){
-                pq_release( ip_globals.net_phone, packet_get_id( next ));
-        }
-        if( ! header ){
-                if( packet_get_data_length( packet ) <= sizeof( ip_header_t )) return ENOMEM;
+        next = pq_detach(packet);
+        if(next){
+                pq_release(ip_globals.net_phone, packet_get_id(next));
+        }
+        if(! header){
+                if(packet_get_data_length(packet) <= sizeof(ip_header_t)){
+                        return ENOMEM;
+                }
                 // get header
-                header = ( ip_header_ref ) packet_get_data( packet );
-                if( ! header ) return EINVAL;
+                header = (ip_header_ref) packet_get_data(packet);
+                if(! header){
+                        return EINVAL;
+                }
         }
         // only for the first fragment
-        if( IP_FRAGMENT_OFFSET( header )) return EINVAL;
+        if(IP_FRAGMENT_OFFSET(header)){
+                return EINVAL;
+        }
         // not for the ICMP protocol
-        if( header->protocol == IPPROTO_ICMP ){
+        if(header->protocol == IPPROTO_ICMP){
                 return EPERM;
         }
         // set the destination address
-        switch( header->version ){
+        switch(header->version){
                 case IPVERSION:
-                        addrlen = sizeof( dest_in );
-                        bzero( & dest_in, addrlen );
+                        addrlen = sizeof(dest_in);
+                        bzero(&dest_in, addrlen);
                         dest_in.sin_family = AF_INET;
-                        memcpy( & dest_in.sin_addr.s_addr, & header->source_address, sizeof( header->source_address ));
-                        dest = ( struct sockaddr * ) & dest_in;
+                        memcpy(&dest_in.sin_addr.s_addr, &header->source_address, sizeof(header->source_address));
+                        dest = (struct sockaddr *) &dest_in;
                         break;
 /*              case IPv6VERSION:
-                        addrlen = sizeof( dest_in6 );
-                        bzero( & dest_in6, addrlen );
+                        addrlen = sizeof(dest_in6);
+                        bzero(&dest_in6, addrlen);
                         dest_in6.sin6_family = AF_INET6;
-                        memcpy( & dest_in6.sin6_addr.s6_addr, );
-                        dest = ( struct sockaddr * ) & dest_in;
+                        memcpy(&dest_in6.sin6_addr.s6_addr,);
+                        dest = (struct sockaddr *) &dest_in;
                         break;
 */              default:
                         return EAFNOSUPPORT;
         }
-        return packet_set_addr( packet, NULL, ( uint8_t * ) dest, addrlen );
-}
-
-int ip_get_icmp_phone( void ){
-        ip_proto_ref    proto;
-        int                             phone;
-
-        fibril_rwlock_read_lock( & ip_globals.protos_lock );
-        proto = ip_protos_find( & ip_globals.protos, IPPROTO_ICMP );
+        return packet_set_addr(packet, NULL, (uint8_t *) dest, addrlen);
+}
+
+int ip_get_icmp_phone(void){
+        ip_proto_ref proto;
+        int phone;
+
+        fibril_rwlock_read_lock(&ip_globals.protos_lock);
+        proto = ip_protos_find(&ip_globals.protos, IPPROTO_ICMP);
         phone = proto ? proto->phone : ENOENT;
-        fibril_rwlock_read_unlock( & ip_globals.protos_lock );
+        fibril_rwlock_read_unlock(&ip_globals.protos_lock);
         return phone;
 }
 
-int ip_prepare_icmp_and_get_phone( services_t error, packet_t packet, ip_header_ref header ){
-        int     phone;
+int ip_prepare_icmp_and_get_phone(services_t error, packet_t packet, ip_header_ref header){
+        int phone;
 
         phone = ip_get_icmp_phone();
-        if( error || ( phone < 0 ) || ip_prepare_icmp( packet, header )){
-                return ip_release_and_return( packet, EINVAL );
+        if(error || (phone < 0) || ip_prepare_icmp(packet, header)){
+                return ip_release_and_return(packet, EINVAL);
         }
         return phone;
 }
 
-int     ip_release_and_return( packet_t packet, int result ){
-        pq_release( ip_globals.net_phone, packet_get_id( packet ));
+int ip_release_and_return(packet_t packet, int result){
+        pq_release(ip_globals.net_phone, packet_get_id(packet));
         return result;
 }
 
-int ip_get_route_req( int ip_phone, ip_protocol_t protocol, const struct sockaddr * destination, socklen_t addrlen, device_id_t * device_id, ip_pseudo_header_ref * header, size_t * headerlen ){
-        struct sockaddr_in *    address_in;
+int ip_get_route_req(int ip_phone, ip_protocol_t protocol, const struct sockaddr * destination, socklen_t addrlen, device_id_t * device_id, ip_pseudo_header_ref * header, size_t * headerlen){
+        struct sockaddr_in * address_in;
 //      struct sockaddr_in6 *   address_in6;
-        in_addr_t *                             dest;
-        in_addr_t *                             src;
-        ip_route_ref                    route;
-        ipv4_pseudo_header_ref  header_in;
-
-        if( !( destination && ( addrlen > 0 ))) return EINVAL;
-        if( !( device_id && header && headerlen )) return EBADMEM;
-        if(( size_t ) addrlen < sizeof( struct sockaddr )){
+        in_addr_t * dest;
+        in_addr_t * src;
+        ip_route_ref route;
+        ipv4_pseudo_header_ref header_in;
+
+        if(!(destination && (addrlen > 0))){
                 return EINVAL;
         }
-        switch( destination->sa_family ){
+        if(!(device_id && header && headerlen)){
+                return EBADMEM;
+        }
+        if((size_t) addrlen < sizeof(struct sockaddr)){
+                return EINVAL;
+        }
+        switch(destination->sa_family){
                 case AF_INET:
-                        if( addrlen != sizeof( struct sockaddr_in )){
+                        if(addrlen != sizeof(struct sockaddr_in)){
                                 return EINVAL;
                         }
-                        address_in = ( struct sockaddr_in * ) destination;
-                        dest = & address_in->sin_addr;
-                        if( ! dest->s_addr ){
+                        address_in = (struct sockaddr_in *) destination;
+                        dest = &address_in->sin_addr;
+                        if(! dest->s_addr){
                                 dest->s_addr = IPV4_LOCALHOST_ADDRESS;
                         }
@@ -1511 +1571 @@
                 // TODO IPv6
 /*              case AF_INET6:
-                        if( addrlen != sizeof( struct sockaddr_in6 )) return EINVAL;
-                        address_in6 = ( struct sockaddr_in6 * ) dest;
+                        if(addrlen != sizeof(struct sockaddr_in6)){
+                                return EINVAL;
+                        }
+                        address_in6 = (struct sockaddr_in6 *) dest;
                         address_in6.sin6_addr.s6_addr;
 */              default:
                         return EAFNOSUPPORT;
         }
-        fibril_rwlock_read_lock( & ip_globals.lock );
-        route = ip_find_route( * dest );
-        if( !( route && route->netif )){
-                fibril_rwlock_read_unlock( & ip_globals.lock );
+        fibril_rwlock_read_lock(&ip_globals.lock);
+        route = ip_find_route(*dest);
+        if(!(route && route->netif)){
+                fibril_rwlock_read_unlock(&ip_globals.lock);
                 return ENOENT;
         }
-        * device_id = route->netif->device_id;
-        src = ip_netif_address( route->netif );
-        fibril_rwlock_read_unlock( & ip_globals.lock );
-        * headerlen = sizeof( * header_in );
-        header_in = ( ipv4_pseudo_header_ref ) malloc( * headerlen );
-        if( ! header_in ) return ENOMEM;
-        bzero( header_in, * headerlen );
+        *device_id = route->netif->device_id;
+        src = ip_netif_address(route->netif);
+        fibril_rwlock_read_unlock(&ip_globals.lock);
+        *headerlen = sizeof(*header_in);
+        header_in = (ipv4_pseudo_header_ref) malloc(*headerlen);
+        if(! header_in){
+                return ENOMEM;
+        }
+        bzero(header_in, * headerlen);
         header_in->destination_address = dest->s_addr;
         header_in->source_address = src->s_addr;
         header_in->protocol = protocol;
         header_in->data_length = 0;
-        * header = ( ip_pseudo_header_ref ) header_in;
+        *header = (ip_pseudo_header_ref) header_in;
         return EOK;
 }

uspace/srv/net/il/ip/ip.h

@@ -90 +90 @@
  *  @see device.h
  */
-DEVICE_MAP_DECLARE( ip_netifs, ip_netif_t )
+DEVICE_MAP_DECLARE(ip_netifs, ip_netif_t)
 
 /** IP registered protocols.
@@ -96 +96 @@
  *  @see int_map.h
  */
-INT_MAP_DECLARE( ip_protos, ip_proto_t )
+INT_MAP_DECLARE(ip_protos, ip_proto_t)
 
 /** IP routing table.
  *  @see generic_field.h
  */
-GENERIC_FIELD_DECLARE( ip_routes, ip_route_t )
+GENERIC_FIELD_DECLARE(ip_routes, ip_route_t)
 
 /** IP network interface specific data.
@@ -108 +108 @@
         /** Device identifier.
          */
-        device_id_t     device_id;
+        device_id_t device_id;
         /** Netif module service.
          */
-        services_t      service;
+        services_t service;
         /** Netif module phone.
          */
-        int                     phone;
+        int phone;
         /** ARP module.
          *  Assigned if using ARP.
          */
-        module_ref      arp;
+        module_ref arp;
         /** IP version.
          */
-        int                     ipv;
+        int ipv;
         /** Indicates whether using DHCP.
          */
-        int                     dhcp;
+        int dhcp;
         /** Indicates whether IP routing is enabled.
          */
-        int                     routing;
+        int routing;
         /** Device state.
          */
-        device_state_t  state;
+        device_state_t state;
         /** Broadcast address.
          */
-        in_addr_t       broadcast;
+        in_addr_t broadcast;
         /** Routing table.
          */
-        ip_routes_t     routes;
+        ip_routes_t routes;
         /** Packet dimension.
          */
-        packet_dimension_t      packet_dimension;
+        packet_dimension_t packet_dimension;
 };
 
@@ -147 +147 @@
         /** Protocol number.
          */
-        int     protocol;
+        int protocol;
         /** Protocol module service.
          */
@@ -153 +153 @@
         /** Protocol module phone.
          */
-        int     phone;
+        int phone;
         /** Protocol packet receiving function.
          */
@@ -164 +164 @@
         /** Target address.
          */
-        in_addr_t               address;
+        in_addr_t address;
         /** Target network mask.
          */
-        in_addr_t               netmask;
+        in_addr_t netmask;
         /** Gateway.
          */
-        in_addr_t               gateway;
+        in_addr_t gateway;
         /** Parent netif.
          */
-        ip_netif_ref    netif;
+        ip_netif_ref netif;
 };
 
@@ -181 +181 @@
         /** Networking module phone.
          */
-        int                     net_phone;
+        int net_phone;
         /** Registered network interfaces.
          */
-        ip_netifs_t     netifs;
+        ip_netifs_t netifs;
         /** Netifs safeyt lock.
          */
-        fibril_rwlock_t netifs_lock;
+        fibril_rwlock_t netifs_lock;
         /** Registered protocols.
          */
-        ip_protos_t     protos;
+        ip_protos_t protos;
         /** Protocols safety lock.
          */
-        fibril_rwlock_t protos_lock;
+        fibril_rwlock_t protos_lock;
         /** Default gateway.
          */
-        ip_route_t      gateway;
+        ip_route_t gateway;
         /** Known support modules.
          */
-        modules_t       modules;
+        modules_t modules;
         /** Default client connection function for support modules.
          */
@@ -205 +205 @@
         /** Packet counter.
          */
-        uint16_t        packet_counter;
+        uint16_t packet_counter;
         /** Safety lock.
          */
-        fibril_rwlock_t lock;
+        fibril_rwlock_t lock;
 };
 

uspace/srv/net/il/ip/ip_client.c

@@ -48 +48 @@
 #include "ip_header.h"
 
-int ip_client_prepare_packet( packet_t packet, ip_protocol_t protocol, ip_ttl_t ttl, ip_tos_t tos, int dont_fragment, size_t ipopt_length ){
-        ip_header_ref   header;
-        uint8_t *               data;
-        size_t                  padding;
+int ip_client_prepare_packet(packet_t packet, ip_protocol_t protocol, ip_ttl_t ttl, ip_tos_t tos, int dont_fragment, size_t ipopt_length){
+        ip_header_ref header;
+        uint8_t * data;
+        size_t padding;
 
         padding =  ipopt_length % 4;
-        if( padding ){
+        if(padding){
                 padding = 4 - padding;
                 ipopt_length += padding;
         }
-        data = ( uint8_t * ) packet_prefix( packet, sizeof( ip_header_t ) + padding );
-        if( ! data ) return ENOMEM;
-        while( padding -- ) data[ sizeof( ip_header_t ) + padding ] = IPOPT_NOOP;
-        header = ( ip_header_ref ) data;
-        header->header_length = IP_COMPUTE_HEADER_LENGTH( sizeof( ip_header_t ) + ipopt_length );
-        header->ttl = ( ttl ? ttl : IPDEFTTL ); //((( ttl ) <= MAXTTL ) ? ttl : MAXTTL ) : IPDEFTTL;
+        data = (uint8_t *) packet_prefix(packet, sizeof(ip_header_t) + padding);
+        if(! data){
+                return ENOMEM;
+        }
+        while(padding --){
+                data[sizeof(ip_header_t) + padding] = IPOPT_NOOP;
+        }
+        header = (ip_header_ref) data;
+        header->header_length = IP_COMPUTE_HEADER_LENGTH(sizeof(ip_header_t) + ipopt_length);
+        header->ttl = (ttl ? ttl : IPDEFTTL); //(((ttl) <= MAXTTL) ? ttl : MAXTTL) : IPDEFTTL;
         header->tos = tos;
         header->protocol = protocol;
-        if( dont_fragment ) header->flags = IPFLAG_DONT_FRAGMENT;
+        if(dont_fragment){
+                header->flags = IPFLAG_DONT_FRAGMENT;
+        }
         return EOK;
 }
 
-int ip_client_process_packet( packet_t packet, ip_protocol_t * protocol, ip_ttl_t * ttl, ip_tos_t * tos, int * dont_fragment, size_t * ipopt_length ){
-        ip_header_ref   header;
+int ip_client_process_packet(packet_t packet, ip_protocol_t * protocol, ip_ttl_t * ttl, ip_tos_t * tos, int * dont_fragment, size_t * ipopt_length){
+        ip_header_ref header;
 
-        header = ( ip_header_ref ) packet_get_data( packet );
-        if(( ! header )
-        || ( packet_get_data_length( packet ) < sizeof( ip_header_t ))){
+        header = (ip_header_ref) packet_get_data(packet);
+        if((! header)
+                || (packet_get_data_length(packet) < sizeof(ip_header_t))){
                 return ENOMEM;
         }
-        if( protocol ) * protocol = header->protocol;
-        if( ttl ) * ttl = header->ttl;
-        if( tos ) * tos = header->tos;
-        if( dont_fragment ) * dont_fragment = header->flags & IPFLAG_DONT_FRAGMENT;
-        if( ipopt_length ){
-                * ipopt_length = IP_HEADER_LENGTH( header ) - sizeof( ip_header_t );
-                return sizeof( ip_header_t );
+        if(protocol){
+                *protocol = header->protocol;
+        }
+        if(ttl){
+                *ttl = header->ttl;
+        }
+        if(tos){
+                *tos = header->tos;
+        }
+        if(dont_fragment){
+                *dont_fragment = header->flags &IPFLAG_DONT_FRAGMENT;
+        }
+        if(ipopt_length){
+                *ipopt_length = IP_HEADER_LENGTH(header) - sizeof(ip_header_t);
+                return sizeof(ip_header_t);
         }else{
-                return IP_HEADER_LENGTH( header );
+                return IP_HEADER_LENGTH(header);
         }
 }
 
-size_t ip_client_header_length( packet_t packet ){
-        ip_header_ref   header;
+size_t ip_client_header_length(packet_t packet){
+        ip_header_ref header;
 
-        header = ( ip_header_ref ) packet_get_data( packet );
-        if(( ! header )
-        || ( packet_get_data_length( packet ) < sizeof( ip_header_t ))){
+        header = (ip_header_ref) packet_get_data(packet);
+        if((! header)
+                || (packet_get_data_length(packet) < sizeof(ip_header_t))){
                 return 0;
         }
-        return IP_HEADER_LENGTH( header );
+        return IP_HEADER_LENGTH(header);
 }
 
-int ip_client_set_pseudo_header_data_length( ip_pseudo_header_ref header, size_t headerlen, size_t data_length ){
-        ipv4_pseudo_header_ref  header_in;
+int ip_client_set_pseudo_header_data_length(ip_pseudo_header_ref header, size_t headerlen, size_t data_length){
+        ipv4_pseudo_header_ref header_in;
 
-        if( ! header ) return EBADMEM;
-        if( headerlen == sizeof( ipv4_pseudo_header_t )){
-                header_in = ( ipv4_pseudo_header_ref ) header;
-                header_in->data_length = htons( data_length );
+        if(! header){
+                return EBADMEM;
+        }
+        if(headerlen == sizeof(ipv4_pseudo_header_t)){
+                header_in = (ipv4_pseudo_header_ref) header;
+                header_in->data_length = htons(data_length);
                 return EOK;
         }else{
@@ -114 +130 @@
 }
 
-int ip_client_get_pseudo_header( ip_protocol_t protocol, struct sockaddr * src, socklen_t srclen, struct sockaddr * dest, socklen_t destlen, size_t data_length, ip_pseudo_header_ref * header, size_t * headerlen ){
-        ipv4_pseudo_header_ref  header_in;
-        struct sockaddr_in *    address_in;
+int ip_client_get_pseudo_header(ip_protocol_t protocol, struct sockaddr * src, socklen_t srclen, struct sockaddr * dest, socklen_t destlen, size_t data_length, ip_pseudo_header_ref * header, size_t * headerlen){
+        ipv4_pseudo_header_ref header_in;
+        struct sockaddr_in * address_in;
 
-        if( !( header && headerlen )) return EBADMEM;
-        if( !( src && dest && ( srclen > 0 ) && (( size_t ) srclen >= sizeof( struct sockaddr )) && ( srclen == destlen ) && ( src->sa_family == dest->sa_family ))) return EINVAL;
-        switch( src->sa_family ){
+        if(!(header && headerlen)){
+                return EBADMEM;
+        }
+        if(!(src && dest && (srclen > 0) && ((size_t) srclen >= sizeof(struct sockaddr)) && (srclen == destlen) && (src->sa_family == dest->sa_family))){
+                return EINVAL;
+        }
+        switch(src->sa_family){
                 case AF_INET:
-                        if( srclen != sizeof( struct sockaddr_in )) return EINVAL;
-                        * headerlen = sizeof( * header_in );
-                        header_in = ( ipv4_pseudo_header_ref ) malloc( * headerlen );
-                        if( ! header_in ) return ENOMEM;
-                        bzero( header_in, * headerlen );
-                        address_in = ( struct sockaddr_in * ) dest;
+                        if(srclen != sizeof(struct sockaddr_in)){
+                                return EINVAL;
+                        }
+                        *headerlen = sizeof(*header_in);
+                        header_in = (ipv4_pseudo_header_ref) malloc(*headerlen);
+                        if(! header_in){
+                                return ENOMEM;
+                        }
+                        bzero(header_in, * headerlen);
+                        address_in = (struct sockaddr_in *) dest;
                         header_in->destination_address = address_in->sin_addr.s_addr;
-                        address_in = ( struct sockaddr_in * ) src;
+                        address_in = (struct sockaddr_in *) src;
                         header_in->source_address = address_in->sin_addr.s_addr;
                         header_in->protocol = protocol;
-                        header_in->data_length = htons( data_length );
-                        * header = ( ip_pseudo_header_ref ) header_in;
+                        header_in->data_length = htons(data_length);
+                        *header = (ip_pseudo_header_ref) header_in;
                         return EOK;
                 // TODO IPv6
 /*              case AF_INET6:
-                        if( addrlen != sizeof( struct sockaddr_in6 )) return EINVAL;
-                        address_in6 = ( struct sockaddr_in6 * ) addr;
+                        if(addrlen != sizeof(struct sockaddr_in6)){
+                                return EINVAL;
+                        }
+                        address_in6 = (struct sockaddr_in6 *) addr;
                         return EOK;
 */              default:

uspace/srv/net/il/ip/ip_header.h

@@ -45 +45 @@
  *  @param[in] header The IP packet header.
  */
-#define IP_HEADER_LENGTH( header )              (( header )->header_length * 4u )
+#define IP_HEADER_LENGTH(header)                ((header)->header_length * 4u)
 
 /** Returns the IP header length.
  *  @param[in] length The IP header length in bytes.
  */
-#define IP_COMPUTE_HEADER_LENGTH( length )              (( uint8_t ) (( length ) / 4u ))
+#define IP_COMPUTE_HEADER_LENGTH(length)                ((uint8_t) ((length) / 4u))
 
 /** Returns the actual IP packet total length.
  *  @param[in] header The IP packet header.
  */
-#define IP_TOTAL_LENGTH( header )               ntohs(( header )->total_length )
+#define IP_TOTAL_LENGTH(header)         ntohs((header)->total_length)
 
 /** Returns the actual IP packet data length.
  *  @param[in] header The IP packet header.
  */
-#define IP_HEADER_DATA_LENGTH( header ) ( IP_TOTAL_LENGTH( header ) - IP_HEADER_LENGTH( header ))
+#define IP_HEADER_DATA_LENGTH(header)   (IP_TOTAL_LENGTH(header) - IP_HEADER_LENGTH(header))
 
 /** Returns the IP packet header checksum.
  *  @param[in] header The IP packet header.
  */
-#define IP_HEADER_CHECKSUM( header )    ( htons( ip_checksum(( uint8_t * )( header ), IP_HEADER_LENGTH( header ))))
+#define IP_HEADER_CHECKSUM(header)      (htons(ip_checksum((uint8_t *)(header), IP_HEADER_LENGTH(header))))
 
 /** Returns the fragment offest.
  *  @param[in] header The IP packet header.
  */
-#define IP_FRAGMENT_OFFSET( header ) (((( header )->fragment_offset_high << 8 ) + ( header )->fragment_offset_low ) * 8u )
+#define IP_FRAGMENT_OFFSET(header) ((((header)->fragment_offset_high << 8) + (header)->fragment_offset_low) * 8u)
 
 /** Returns the fragment offest high bits.
  *  @param[in] length The prefixed data total length.
  */
-#define IP_COMPUTE_FRAGMENT_OFFSET_HIGH( length ) (((( length ) / 8u ) & 0x1F00 ) >> 8 )
+#define IP_COMPUTE_FRAGMENT_OFFSET_HIGH(length) ((((length) / 8u) &0x1F00) >> 8)
 
 /** Returns the fragment offest low bits.
  *  @param[in] length The prefixed data total length.
  */
-#define IP_COMPUTE_FRAGMENT_OFFSET_LOW( length ) ((( length ) / 8u ) & 0xFF )
+#define IP_COMPUTE_FRAGMENT_OFFSET_LOW(length) (((length) / 8u) &0xFF)
 
 /** Type definition of the internet header.
@@ -99 +99 @@
         /** The Version field indicates the format of the internet header.
          */
-        uint8_t         version:4;
+        uint8_t version:4;
         /** Internet Header Length is the length of the internet header in 32~bit words, and thus points to the beginning of the data.
          *  Note that the minimum value for a~correct header is~5.
          */
-        uint8_t         header_length:4;
+        uint8_t header_length:4;
 #else
         /** Internet Header Length is the length of the internet header in 32~bit words, and thus points to the beginning of the data.
          *  Note that the minimum value for a~correct header is~5.
          */
-        uint8_t         header_length:4;
+        uint8_t header_length:4;
         /** The Version field indicates the format of the internet header.
          */
-        uint8_t         version:4;
+        uint8_t version:4;
 #endif
         /** The Type of Service provides an indication of the abstract parameters of the quality of service desired.
@@ -118 +118 @@
          *  The major choice is a~three way tradeoff between low-delay, high-reliability, and high-throughput.
          */
-        uint8_t         tos;
+        uint8_t tos;
         /** Total Length is the length of the datagram, measured in octets, including internet header and data.
          *  This field allows the length of a~datagram to be up to 65,535~octets.
          */
-        uint16_t        total_length;
+        uint16_t total_length;
         /** An identifying value assigned by the sender to aid in assembling the fragments of a~datagram.
          */
-        uint16_t        identification;
+        uint16_t identification;
 #ifdef ARCH_IS_BIG_ENDIAN
         /** Various control flags.
          */
-        uint8_t flags:3;
+        uint8_t flags:3;
         /** This field indicates where in the datagram this fragment belongs.
          *  High bits.
          */
-        uint8_t fragment_offset_high:5;
+        uint8_t fragment_offset_high:5;
 #else
         /** This field indicates where in the datagram this fragment belongs.
          *  High bits.
          */
-        uint8_t fragment_offset_high:5;
+        uint8_t fragment_offset_high:5;
         /** Various control flags.
          */
-        uint8_t flags:3;
+        uint8_t flags:3;
 #endif
         /** This field indicates where in the datagram this fragment belongs.
          *  Low bits.
          */
-        uint8_t fragment_offset_low;
+        uint8_t fragment_offset_low;
         /** This field indicates the maximum time the datagram is allowed to remain in the internet system.
          *  If this field contains the value zero, then the datagram must be destroyed.
@@ -153 +153 @@
          *  The intention is to cause undeliverable datagrams to be discarded, and to bound the maximum datagram lifetime.
          */
-        uint8_t         ttl;
+        uint8_t ttl;
         /** This field indicates the next level protocol used in the data portion of the internet datagram.
          */
-        uint8_t         protocol;
+        uint8_t protocol;
         /** A checksum of the header only.
          *  Since some header fields change (e.g., time to live), this is recomputed and verified at each point that the internet header is processed.
@@ -162 +162 @@
          *  For purposes of computing the checksum, the value of the checksum field is zero.
          */
-        uint16_t        header_checksum;
+        uint16_t header_checksum;
         /** The source address.
          */
-        uint32_t        source_address;
+        uint32_t source_address;
         /** The destination address.
          */
-        uint32_t        destination_address;
+        uint32_t destination_address;
 } __attribute__ ((packed));
 
@@ -188 +188 @@
         /** A single octet of option-type.
          */
-        uint8_t         type;
+        uint8_t type;
         /** An option length octet.
          */
-        uint8_t         length;
+        uint8_t length;
         /** A~pointer.
          */
-        uint8_t         pointer;
+        uint8_t pointer;
 #ifdef ARCH_IS_BIG_ENDIAN
         /** The number of IP modules that cannot register timestamps due to lack of space.
          */
-        uint8_t overflow:4;
+        uint8_t overflow:4;
         /** Various internet timestamp control flags.
          */
-        uint8_t flags:4;
+        uint8_t flags:4;
 #else
         /** Various internet timestamp control flags.
          */
-        uint8_t flags:4;
+        uint8_t flags:4;
         /** The number of IP modules that cannot register timestamps due to lack of space.
          */
-        uint8_t overflow:4;
+        uint8_t overflow:4;
 #endif
 } __attribute__ ((packed));
@@ -227 +227 @@
  *  Allows the packet fragmentation.
  */
-#define IPFLAG_MAY_FRAGMENT                     ( 0x0 << IPFLAG_FRAGMENT_SHIFT )
+#define IPFLAG_MAY_FRAGMENT                     (0x0 << IPFLAG_FRAGMENT_SHIFT)
 
 /** Don't fragment flag value.
  *  Permits the packet fragmentation.
  */
-#define IPFLAG_DONT_FRAGMENT            ( 0x1 << IPFLAG_FRAGMENT_SHIFT )
+#define IPFLAG_DONT_FRAGMENT            (0x1 << IPFLAG_FRAGMENT_SHIFT)
 
 /** Last fragment flag value.
  *  Indicates the last packet fragment.
  */
-#define IPFLAG_LAST_FRAGMENT            ( 0x0 << IPFLAG_FRAGMENTED_SHIFT )
+#define IPFLAG_LAST_FRAGMENT            (0x0 << IPFLAG_FRAGMENTED_SHIFT)
 
 /** More fragments flag value.
  *  Indicates that more packet fragments follow.
  */
-#define IPFLAG_MORE_FRAGMENTS           ( 0x1 << IPFLAG_FRAGMENTED_SHIFT )
+#define IPFLAG_MORE_FRAGMENTS           (0x1 << IPFLAG_FRAGMENTED_SHIFT)
 
 /*@}*/
@@ -261 +261 @@
         /** The source address.
          */
-        uint32_t        source_address;
+        uint32_t source_address;
         /** The destination address.
          */
-        uint32_t        destination_address;
+        uint32_t destination_address;
         /** Reserved byte.
          *  Must be zero.
          */
-        uint8_t         reserved;
+        uint8_t reserved;
         /** This field indicates the next level protocol used in the data portion of the internet datagram.
          */
-        uint8_t         protocol;
+        uint8_t protocol;
         /** Data length is the length of the datagram, measured in octets.
          */
-        uint16_t        data_length;
+        uint16_t data_length;
 } __attribute__ ((packed));
 

uspace/srv/net/il/ip/ip_messages.h

@@ -72 +72 @@
  *  @param[in] call The message call structure.
  */
-#define IP_GET_GATEWAY( call )          ({ in_addr_t addr; addr.s_addr = IPC_GET_ARG2( * call ); addr; })
+#define IP_GET_GATEWAY(call)            ({in_addr_t addr; addr.s_addr = IPC_GET_ARG2(*call); addr;})
 
 /** Returns the address message parameter.
  *  @param[in] call The message call structure.
  */
-#define IP_GET_ADDRESS( call )          ({ in_addr_t addr; addr.s_addr = IPC_GET_ARG3( * call ); addr; })
+#define IP_GET_ADDRESS(call)            ({in_addr_t addr; addr.s_addr = IPC_GET_ARG3(*call); addr;})
 
 /** Returns the network mask message parameter.
  *  @param[in] call The message call structure.
  */
-#define IP_GET_NETMASK( call )          ({ in_addr_t addr; addr.s_addr = IPC_GET_ARG4( * call ); addr; })
+#define IP_GET_NETMASK(call)            ({in_addr_t addr; addr.s_addr = IPC_GET_ARG4(*call); addr;})
 
 /** Returns the protocol message parameter.
  *  @param[in] call The message call structure.
  */
-#define IP_GET_PROTOCOL( call )         (( ip_protocol_t ) IPC_GET_ARG1( * call ))
+#define IP_GET_PROTOCOL(call)           ((ip_protocol_t) IPC_GET_ARG1(*call))
 
 /** Sets the header length in the message answer.
  *  @param[out] answer The message answer structure.
  */
-#define IP_SET_HEADERLEN( answer )      (( size_t * ) & IPC_GET_ARG2( * answer ))
+#define IP_SET_HEADERLEN(answer)        ((size_t *) &IPC_GET_ARG2(*answer))
 
 /*@}*/

uspace/srv/net/il/ip/ip_module.c

@@ -61 +61 @@
  *  @see NAME
  */
-void    module_print_name( void );
+void module_print_name(void);
 
 /** Starts the IP module.
@@ -70 +70 @@
  *  @returns Other error codes as defined for the REGISTER_ME() macro function.
  */
-int     module_start( async_client_conn_t client_connection );
+int module_start(async_client_conn_t client_connection);
 
 /** Processes the IP message.
@@ -80 +80 @@
  *  @returns Other error codes as defined for the ip_message() function.
  */
-int     module_message( ipc_callid_t callid, ipc_call_t * call, ipc_call_t * answer, int * answer_count );
+int module_message(ipc_callid_t callid, ipc_call_t * call, ipc_call_t * answer, int * answer_count);
 
 /** IP module global data.
@@ -86 +86 @@
 extern ip_globals_t     ip_globals;
 
-void module_print_name( void ){
-        printf( "%s", NAME );
+void module_print_name(void){
+        printf("%s", NAME);
 }
 
-int module_start( async_client_conn_t client_connection ){
+int module_start(async_client_conn_t client_connection){
         ERROR_DECLARE;
 
-        ipcarg_t        phonehash;
+        ipcarg_t phonehash;
 
-        async_set_client_connection( client_connection );
-        ip_globals.net_phone = net_connect_module( SERVICE_NETWORKING );
-        ERROR_PROPAGATE( pm_init());
-        if( ERROR_OCCURRED( ip_initialize( client_connection ))
-        || ERROR_OCCURRED( REGISTER_ME( SERVICE_IP, & phonehash ))){
+        async_set_client_connection(client_connection);
+        ip_globals.net_phone = net_connect_module(SERVICE_NETWORKING);
+        ERROR_PROPAGATE(pm_init());
+        if(ERROR_OCCURRED(ip_initialize(client_connection))
+                || ERROR_OCCURRED(REGISTER_ME(SERVICE_IP, &phonehash))){
                 pm_destroy();
                 return ERROR_CODE;
@@ -110 +110 @@
 }
 
-int     module_message( ipc_callid_t callid, ipc_call_t * call, ipc_call_t * answer, int * answer_count ){
-        return ip_message( callid, call, answer, answer_count );
+int module_message(ipc_callid_t callid, ipc_call_t * call, ipc_call_t * answer, int * answer_count){
+        return ip_message(callid, call, answer, answer_count);
 }
 

uspace/srv/net/il/ip/ip_module.h

@@ -46 +46 @@
  *  @returns ENOMEM if there is not enough memory left.
  */
-int     ip_initialize( async_client_conn_t client_connection );
+int ip_initialize(async_client_conn_t client_connection);
 
 /** Processes the IP message.
@@ -59 +59 @@
  *  @see IS_NET_IP_MESSAGE()
  */
-int     ip_message( ipc_callid_t callid, ipc_call_t * call, ipc_call_t * answer, int * answer_count );
+int ip_message(ipc_callid_t callid, ipc_call_t * call, ipc_call_t * answer, int * answer_count);
 
 #endif

uspace/srv/net/il/ip/ip_remote.c

@@ -52 +52 @@
 #include "ip_messages.h"
 
-int ip_device_req( int ip_phone, device_id_t device_id, services_t service ){
-        return generic_device_req( ip_phone, NET_IL_DEVICE, device_id, 0, service );
+int ip_device_req(int ip_phone, device_id_t device_id, services_t service){
+        return generic_device_req(ip_phone, NET_IL_DEVICE, device_id, 0, service);
 }
 
-int ip_send_msg( int ip_phone, device_id_t device_id, packet_t packet, services_t sender, services_t error ){
-        return generic_send_msg( ip_phone, NET_IL_SEND, device_id, packet_get_id( packet ), sender, error );
+int ip_send_msg(int ip_phone, device_id_t device_id, packet_t packet, services_t sender, services_t error){
+        return generic_send_msg(ip_phone, NET_IL_SEND, device_id, packet_get_id(packet), sender, error);
 }
 
-int ip_connect_module( services_t service ){
-        return connect_to_service( SERVICE_IP );
+int ip_connect_module(services_t service){
+        return connect_to_service(SERVICE_IP);
 }
 
-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 ){
-        return ( int ) async_req_4_0( ip_phone, NET_IP_ADD_ROUTE, ( ipcarg_t ) device_id, ( ipcarg_t ) gateway.s_addr, ( ipcarg_t ) address.s_addr, ( ipcarg_t ) netmask.s_addr );
+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){
+        return (int) async_req_4_0(ip_phone, NET_IP_ADD_ROUTE, (ipcarg_t) device_id, (ipcarg_t) gateway.s_addr, (ipcarg_t) address.s_addr, (ipcarg_t) netmask.s_addr);
 }
 
-int ip_set_gateway_req( int ip_phone, device_id_t device_id, in_addr_t gateway ){
-        return ( int ) async_req_2_0( ip_phone, NET_IP_SET_GATEWAY, ( ipcarg_t ) device_id, ( ipcarg_t ) gateway.s_addr );
+int ip_set_gateway_req(int ip_phone, device_id_t device_id, in_addr_t gateway){
+        return (int) async_req_2_0(ip_phone, NET_IP_SET_GATEWAY, (ipcarg_t) device_id, (ipcarg_t) gateway.s_addr);
 }
 
-int ip_packet_size_req( int ip_phone, device_id_t device_id, packet_dimension_ref packet_dimension ){
-        return generic_packet_size_req( ip_phone, NET_IL_PACKET_SPACE, device_id, packet_dimension );
+int ip_packet_size_req(int ip_phone, device_id_t device_id, packet_dimension_ref packet_dimension){
+        return generic_packet_size_req(ip_phone, NET_IL_PACKET_SPACE, device_id, packet_dimension);
 }
 
-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 ( int ) bind_service( service, ( ipcarg_t ) protocol, me, service, receiver );
+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 (int) bind_service(service, (ipcarg_t) protocol, me, service, receiver);
 }
 
-int ip_received_error_msg( int ip_phone, device_id_t device_id, packet_t packet, services_t target, services_t error ){
-        return generic_received_msg( ip_phone, NET_IP_RECEIVED_ERROR, device_id, packet_get_id( packet ), target, error );
+int ip_received_error_msg(int ip_phone, device_id_t device_id, packet_t packet, services_t target, services_t error){
+        return generic_received_msg(ip_phone, NET_IP_RECEIVED_ERROR, device_id, packet_get_id(packet), target, error);
 }
 
-int ip_get_route_req( int ip_phone, ip_protocol_t protocol, const struct sockaddr * destination, socklen_t addrlen, device_id_t * device_id, ip_pseudo_header_ref * header, size_t * headerlen ){
-        aid_t                   message_id;
-        ipcarg_t                result;
-        ipc_call_t              answer;
+int ip_get_route_req(int ip_phone, ip_protocol_t protocol, const struct sockaddr * destination, socklen_t addrlen, device_id_t * device_id, ip_pseudo_header_ref * header, size_t * headerlen){
+        aid_t message_id;
+        ipcarg_t result;
+        ipc_call_t answer;
 
-        if( !( destination && ( addrlen > 0 ))) return EINVAL;
-        if( !( device_id && header && headerlen )) return EBADMEM;
-        * header = NULL;
-        message_id = async_send_1( ip_phone, NET_IP_GET_ROUTE, ( ipcarg_t ) protocol, & answer );
-        if(( async_data_write_start( ip_phone, destination, addrlen ) == EOK )
-        && ( async_data_read_start( ip_phone, headerlen, sizeof( * headerlen )) == EOK )
-        && ( * headerlen > 0 )){
-                * header = ( ip_pseudo_header_ref ) malloc( * headerlen );
-                if( * header ){
-                        if( async_data_read_start( ip_phone, * header, * headerlen ) != EOK ){
-                                free( * header );
+        if(!(destination && (addrlen > 0))){
+                return EINVAL;
+        }
+        if(!(device_id && header && headerlen)){
+                return EBADMEM;
+        }
+        *header = NULL;
+        message_id = async_send_1(ip_phone, NET_IP_GET_ROUTE, (ipcarg_t) protocol, &answer);
+        if((async_data_write_start(ip_phone, destination, addrlen) == EOK)
+                && (async_data_read_start(ip_phone, headerlen, sizeof(*headerlen)) == EOK)
+                && (*headerlen > 0)){
+                *header = (ip_pseudo_header_ref) malloc(*headerlen);
+                if(*header){
+                        if(async_data_read_start(ip_phone, * header, * headerlen) != EOK){
+                                free(*header);
                         }
                 }
         }
-        async_wait_for( message_id, & result );
-        if(( result != EOK ) && ( * header )){
-                free( * header );
+        async_wait_for(message_id, &result);
+        if((result != EOK) && (*header)){
+                free(*header);
         }else{
-                * device_id = IPC_GET_DEVICE( & answer );
+                *device_id = IPC_GET_DEVICE(&answer);
         }
-        return ( int ) result;
+        return (int) result;
 }