Index: uspace/srv/net/il/arp/arp.c
===================================================================
--- uspace/srv/net/il/arp/arp.c	(revision 91478aae14d21fad32ae117b2ac0b0fd52f11394)
+++ uspace/srv/net/il/arp/arp.c	(revision 71b00dcceb98187a198867584792b49778d8e886)
@@ -81,10 +81,10 @@
  *  @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,5 +103,5 @@
  *  @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,5 +116,5 @@
  *  @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,5 +131,5 @@
  *  @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,73 +139,77 @@
  *  @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,22 +217,22 @@
 
 	// 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,30 +240,32 @@
 		}
 	}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,213 +273,235 @@
 }
 
-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,100 +510,108 @@
 }
 
-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;
