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

Rev	Author	Line No.	Line
3466	mejdrech	1	/*
3912	mejdrech	2	* Copyright (c) 2009 Lukas Mejdrech
3466	mejdrech	3	* All rights reserved.
		4	*
		5	* Redistribution and use in source and binary forms, with or without
		6	* modification, are permitted provided that the following conditions
		7	* are met:
		8	*
		9	* - Redistributions of source code must retain the above copyright
		10	* notice, this list of conditions and the following disclaimer.
		11	* - Redistributions in binary form must reproduce the above copyright
		12	* notice, this list of conditions and the following disclaimer in the
		13	* documentation and/or other materials provided with the distribution.
		14	* - The name of the author may not be used to endorse or promote products
		15	* derived from this software without specific prior written permission.
		16	*
		17	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
		18	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
		19	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
		20	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
		21	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
		22	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
		23	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
		24	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
		25	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
		26	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
		27	*/
		28
3912	mejdrech	29	/** @addtogroup ip
		30	* @{
3466	mejdrech	31	*/
		32
		33	/** @file
4702	mejdrech	34	* IP module implementation.
		35	* @see arp.h
3466	mejdrech	36	*/
3666	mejdrech	37
3466	mejdrech	38	#include <async.h>
		39	#include <errno.h>
4582	mejdrech	40	#include <fibril_sync.h>
3466	mejdrech	41	#include <stdio.h>
4327	mejdrech	42	#include <string.h>
3846	mejdrech	43
3466	mejdrech	44	#include <ipc/ipc.h>
		45	#include <ipc/services.h>
		46
4505	mejdrech	47	#include <sys/types.h>
		48
3886	mejdrech	49	#include "../../err.h"
		50	#include "../../messages.h"
		51	#include "../../modules.h"
3466	mejdrech	52
4720	mejdrech	53	#include "../../include/arp_interface.h"
4505	mejdrech	54	#include "../../include/byteorder.h"
4743	mejdrech	55	#include "../../include/checksum.h"
4243	mejdrech	56	#include "../../include/device.h"
4720	mejdrech	57	#include "../../include/icmp_client.h"
		58	#include "../../include/icmp_codes.h"
		59	#include "../../include/icmp_interface.h"
4307	mejdrech	60	#include "../../include/il_interface.h"
4720	mejdrech	61	#include "../../include/in.h"
		62	#include "../../include/in6.h"
		63	#include "../../include/inet.h"
4505	mejdrech	64	#include "../../include/ip_client.h"
4307	mejdrech	65	#include "../../include/ip_interface.h"
4720	mejdrech	66	#include "../../include/net_interface.h"
		67	#include "../../include/nil_interface.h"
4505	mejdrech	68	#include "../../include/tl_interface.h"
4720	mejdrech	69	#include "../../include/socket_codes.h"
		70	#include "../../include/socket_errno.h"
3886	mejdrech	71	#include "../../structures/measured_strings.h"
4192	mejdrech	72	#include "../../structures/module_map.h"
3901	mejdrech	73	#include "../../structures/packet/packet_client.h"
3846	mejdrech	74
4307	mejdrech	75	#include "../../nil/nil_messages.h"
		76
		77	#include "../il_messages.h"
		78
3466	mejdrech	79	#include "ip.h"
4505	mejdrech	80	#include "ip_header.h"
		81	#include "ip_messages.h"
3846	mejdrech	82	#include "ip_module.h"
3466	mejdrech	83
4722	mejdrech	84	/** IP version 4.
4702	mejdrech	85	*/
4722	mejdrech	86	#define IPV4 4
4702	mejdrech	87
4722	mejdrech	88	/** Default network interface IP version.
		89	*/
		90	#define NET_DEFAULT_IPV IPV4
		91
		92	/** Default network interface IP routing.
		93	*/
		94	#define NET_DEFAULT_IP_ROUTING false
		95
4702	mejdrech	96	/** Minimum IP packet content.
		97	*/
4505	mejdrech	98	#define IP_MIN_CONTENT 576
3685	mejdrech	99
4702	mejdrech	100	/** ARP module name.
		101	*/
4192	mejdrech	102	#define ARP_NAME "arp"
4702	mejdrech	103
		104	/** ARP module filename.
		105	*/
4192	mejdrech	106	#define ARP_FILENAME "/srv/arp"
		107
4702	mejdrech	108	/** IP packet address length.
		109	*/
4720	mejdrech	110	#define IP_ADDR sizeof( struct sockaddr_in6 )
4702	mejdrech	111
		112	/** IP packet prefix length.
		113	*/
4505	mejdrech	114	#define IP_PREFIX sizeof( ip_header_t )
4702	mejdrech	115
		116	/** IP packet suffix length.
		117	*/
4505	mejdrech	118	#define IP_SUFFIX 0
4702	mejdrech	119
		120	/** IP packet maximum content length.
		121	*/
4505	mejdrech	122	#define IP_MAX_CONTENT 65535
4702	mejdrech	123
4724	mejdrech	124	/** The IP localhost address.
		125	*/
		126	#define IPV4_LOCALHOST_ADDRESS htonl(( 127 << 24 ) + 1 )
		127
4702	mejdrech	128	/** IP global data.
		129	*/
3666	mejdrech	130	ip_globals_t ip_globals;
3466	mejdrech	131
3666	mejdrech	132	DEVICE_MAP_IMPLEMENT( ip_netifs, ip_netif_t )
		133
3846	mejdrech	134	INT_MAP_IMPLEMENT( ip_protos, ip_proto_t )
3685	mejdrech	135
4505	mejdrech	136	GENERIC_FIELD_IMPLEMENT( ip_routes, ip_route_t )
		137
4702	mejdrech	138	/** Updates the device content length according to the new MTU value.
4756	mejdrech	139	* @param[in] device_id The device identifier.
		140	* @param[in] mtu The new mtu value.
4702	mejdrech	141	* @returns EOK on success.
		142	* @returns ENOENT if device is not found.
		143	*/
		144	int ip_mtu_changed_message( device_id_t device_id, size_t mtu );
		145
		146	/** Updates the device state.
4756	mejdrech	147	* @param[in] device_id The device identifier.
		148	* @param[in] state The new state value.
4702	mejdrech	149	* @returns EOK on success.
		150	* @returns ENOENT if device is not found.
		151	*/
		152	int ip_device_state_message( device_id_t device_id, device_state_t state );
		153
4756	mejdrech	154	/** Registers the transport layer protocol.
		155	* The traffic of this protocol will be supplied using either the receive function or IPC message.
		156	* @param[in] protocol The transport layer module protocol.
		157	* @param[in] service The transport layer module service.
		158	* @param[in] phone The transport layer module phone.
		159	* @param[in] tl_received_msg The receiving function.
		160	* @returns EOK on success.
		161	* @returns EINVAL if the protocol parameter and/or the service parameter is zero (0).
		162	* @returns EINVAL if the phone parameter is not a positive number and the tl_receive_msg is NULL.
		163	* @returns ENOMEM if there is not enough memory left.
		164	*/
4505	mejdrech	165	int ip_register( int protocol, services_t service, int phone, tl_received_msg_t tl_received_msg );
4702	mejdrech	166
		167	/** Initializes a new network interface specific data.
		168	* Connects to the network interface layer module, reads the netif configuration, starts an ARP module if needed and sets the netif routing table.
		169	* The device identifier and the nil service has to be set.
4756	mejdrech	170	* @param[in,out] ip_netif Network interface specific data.
4702	mejdrech	171	* @returns EOK on success.
		172	* @returns ENOTSUP if DHCP is configured.
		173	* @returns ENOTSUP if IPv6 is configured.
		174	* @returns EINVAL if any of the addresses is invalid.
		175	* @returns EINVAL if the used ARP module is not known.
		176	* @returns ENOMEM if there is not enough memory left.
		177	* @returns Other error codes as defined for the net_get_device_conf_req() function.
		178	* @returns Other error codes as defined for the bind_service() function.
		179	* @returns Other error codes as defined for the specific arp_device_req() function.
		180	* @returns Other error codes as defined for the nil_packet_size_req() function.
		181	*/
4505	mejdrech	182	int ip_netif_initialize( ip_netif_ref ip_netif );
3846	mejdrech	183
4756	mejdrech	184	/** Sends the packet or the packet queue via the specified route.
		185	* The ICMP_HOST_UNREACH error notification may be sent if route hardware destination address is found.
		186	* @param[in,out] packet The packet to be sent.
		187	* @param[in] netif The target network interface.
		188	* @param[in] route The target route.
		189	* @param[in] src The source address.
		190	* @param[in] dest The destination address.
		191	* @param[in] error The error module service.
		192	* @returns EOK on success.
		193	* @returns Other error codes as defined for the arp_translate_req() function.
		194	* @returns Other error codes as defined for the ip_prepare_packet() function.
		195	*/
4707	mejdrech	196	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 );
4756	mejdrech	197
		198	/** Prepares the outgoing packet or the packet queue.
		199	* The packet queue is a fragmented packet
		200	* Updates the first packet's IP header.
		201	* Prefixes the additional packets with fragment headers.
		202	* @param[in] source The source address.
		203	* @param[in] dest The destination address.
		204	* @param[in,out] packet The packet to be sent.
		205	* @param[in] destination The destination hardware address.
		206	* @returns EOK on success.
		207	* @returns EINVAL if the packet is too small to contain the IP header.
		208	* @returns EINVAL if the packet is too long than the IP allows.
		209	* @returns ENOMEM if there is not enough memory left.
		210	* @returns Other error codes as defined for the packet_set_addr() function.
		211	*/
4575	mejdrech	212	int ip_prepare_packet( in_addr_t * source, in_addr_t dest, packet_t packet, measured_string_ref destination );
4505	mejdrech	213
4756	mejdrech	214	/** Checks the packet queue lengths and fragments the packets if needed.
		215	* The ICMP_FRAG_NEEDED error notification may be sent if the packet needs to be fragmented and the fragmentation is not allowed.
		216	* @param[in,out] packet The packet or the packet queue to be checked.
		217	* @param[in] prefix The minimum prefix size.
		218	* @param[in] content The maximum content size.
		219	* @param[in] suffix The minimum suffix size.
		220	* @param[in] addr_len The minimum address length.
		221	* @param[in] error The error module service.
		222	* @returns The packet or the packet queue of the allowed length.
		223	* @returns NULL if there are no packets left.
		224	*/
4720	mejdrech	225	packet_t ip_split_packet( packet_t packet, size_t prefix, size_t content, size_t suffix, socklen_t addr_len, services_t error );
4756	mejdrech	226
		227	/** Checks the packet length and fragments it if needed.
		228	* The new fragments are queued before the original packet.
		229	* @param[in,out] packet The packet to be checked.
		230	* @param[in] length The maximum packet length.
		231	* @param[in] prefix The minimum prefix size.
		232	* @param[in] suffix The minimum suffix size.
		233	* @param[in] addr_len The minimum address length.
		234	* @returns EOK on success.
		235	* @returns EINVAL if the packet_get_addr() function fails.
		236	* @returns EINVAL if the packet does not contain the IP header.
		237	* @returns EPERM if the packet needs to be fragmented and the fragmentation is not allowed.
		238	* @returns ENOMEM if there is not enough memory left.
		239	* @returns ENOMEM if there is no packet available.
		240	* @returns ENOMEM if the packet is too small to contain the IP header.
		241	* @returns Other error codes as defined for the packet_trim() function.
		242	* @returns Other error codes as defined for the ip_create_middle_header() function.
		243	* @returns Other error codes as defined for the ip_fragment_packet_data() function.
		244	*/
4720	mejdrech	245	int ip_fragment_packet( packet_t packet, size_t length, size_t prefix, size_t suffix, socklen_t addr_len );
4756	mejdrech	246
		247	/** Fragments the packet from the end.
		248	* @param[in] packet The packet to be fragmented.
		249	* @param[in,out] new_packet The new packet fragment.
		250	* @param[in,out] header The original packet header.
		251	* @param[in,out] new_header The new packet fragment header.
		252	* @param[in] length The new fragment length.
		253	* @param[in] src The source address.
		254	* @param[in] dest The destiantion address.
		255	* @param[in] addrlen The address length.
		256	* @returns EOK on success.
		257	* @returns ENOMEM if the target packet is too small.
		258	* @returns Other error codes as defined for the packet_set_addr() function.
		259	* @returns Other error codes as defined for the pq_insert_after() function.
		260	*/
4720	mejdrech	261	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 );
4756	mejdrech	262
		263	/** Prefixes a middle fragment header based on the last fragment header to the packet.
		264	* @param[in] packet The packet to be prefixed.
		265	* @param[in] last The last header to be copied.
		266	* @returns The prefixed middle header.
		267	* @returns NULL on error.
		268	*/
4505	mejdrech	269	ip_header_ref ip_create_middle_header( packet_t packet, ip_header_ref last );
4756	mejdrech	270
		271	/** Copies the fragment header.
		272	* Copies only the header itself and relevant IP options.
		273	* @param[out] last The created header.
		274	* @param[in] first The original header to be copied.
		275	*/
4589	mejdrech	276	void ip_create_last_header( ip_header_ref last, ip_header_ref first );
4505	mejdrech	277
4756	mejdrech	278	/** Returns the network interface's IP address.
		279	* @param[in] netif The network interface.
		280	* @returns The IP address.
		281	* @returns NULL if no IP address was found.
		282	*/
4707	mejdrech	283	in_addr_t * ip_netif_address( ip_netif_ref netif );
4756	mejdrech	284
		285	/** Searches all network interfaces if there is a suitable route.
		286	* @param[in] destination The destination address.
		287	* @returns The found route.
		288	* @returns NULL if no route was found.
		289	*/
4505	mejdrech	290	ip_route_ref ip_find_route( in_addr_t destination );
4756	mejdrech	291
		292	/** Searches the network interfaces if there is a suitable route.
		293	* @param[in] netif The network interface to be searched for routes. May be NULL.
		294	* @param[in] destination The destination address.
		295	* @returns The found route.
		296	* @returns NULL if no route was found.
		297	*/
4505	mejdrech	298	ip_route_ref ip_netif_find_route( ip_netif_ref netif, in_addr_t destination );
		299
4756	mejdrech	300	/** Processes the received IP packet or the packet queue one by one.
		301	* The packet is either passed to another module or released on error.
		302	* @param[in] device_id The source device identifier.
		303	* @param[in,out] packet The received packet.
4702	mejdrech	304	* @returns EOK on success and the packet is no longer needed.
		305	* @returns EINVAL if the packet is too small to carry the IP packet.
		306	* @returns EINVAL if the received address lengths differs from the registered values.
		307	* @returns ENOENT if the device is not found in the cache.
		308	* @returns ENOENT if the protocol for the device is not found in the cache.
		309	* @returns ENOMEM if there is not enough memory left.
		310	*/
		311	int ip_receive_message( device_id_t device_id, packet_t packet );
		312
4756	mejdrech	313	/** Processes the received packet.
		314	* The packet is either passed to another module or released on error.
		315	* The ICMP_PARAM_POINTER error notification may be sent if the checksum is invalid.
		316	* The ICMP_EXC_TTL error notification may be sent if the TTL is less than two (2).
		317	* The ICMP_HOST_UNREACH error notification may be sent if no route was found.
		318	* The ICMP_HOST_UNREACH error notification may be sent if the packet is for another host and the routing is disabled.
		319	* @param[in] device_id The source device identifier.
		320	* @param[in] packet The received packet to be processed.
		321	* @returns EOK on success.
		322	* @returns EINVAL if the TTL is less than two (2).
		323	* @returns EINVAL if the checksum is invalid.
		324	* @returns EAFNOSUPPORT if the address family is not supported.
		325	* @returns ENOENT if no route was found.
		326	* @returns ENOENT if the packet is for another host and the routing is disabled.
		327	*/
4505	mejdrech	328	int ip_process_packet( device_id_t device_id, packet_t packet );
4756	mejdrech	329
		330	/** Returns the packet destination address from the IP header.
		331	* @param[in] header The packet IP header to be read.
		332	* @returns The packet destination address.
		333	*/
4505	mejdrech	334	in_addr_t ip_get_destination( ip_header_ref header );
4756	mejdrech	335
		336	/** Delivers the packet to the local host.
		337	* The packet is either passed to another module or released on error.
		338	* The ICMP_PROT_UNREACH error notification may be sent if the protocol is not found.
		339	* @param[in] device_id The source device identifier.
		340	* @param[in] packet The packet to be delivered.
		341	* @param[in] header The first packet IP header. May be NULL.
		342	* @param[in] error The packet error service.
		343	* @returns EOK on success.
		344	* @returns ENOTSUP if the packet is a fragment.
		345	* @returns EAFNOSUPPORT if the address family is not supported.
		346	* @returns ENOENT if the target protocol is not found.
		347	* @returns Other error codes as defined for the packet_set_addr() function.
		348	* @returns Other error codes as defined for the packet_trim() function.
		349	* @returns Other error codes as defined for the protocol specific tl_received_msg function.
		350	*/
4707	mejdrech	351	int ip_deliver_local( device_id_t device_id, packet_t packet, ip_header_ref header, services_t error );
4505	mejdrech	352
4756	mejdrech	353	/** Prepares the ICMP notification packet.
		354	* Releases additional packets and keeps only the first one.
		355	* All packets is released on error.
		356	* @param[in] error The packet error service.
		357	* @param[in] packet The packet or the packet queue to be reported as faulty.
		358	* @param[in] header The first packet IP header. May be NULL.
		359	* @returns The found ICMP phone.
		360	* @returns EINVAL if the error parameter is set.
		361	* @returns EINVAL if the ICMP phone is not found.
		362	* @returns EINVAL if the ip_prepare_icmp() fails.
		363	*/
4707	mejdrech	364	int ip_prepare_icmp_and_get_phone( services_t error, packet_t packet, ip_header_ref header );
4756	mejdrech	365
		366	/** Returns the ICMP phone.
		367	* Searches the registered protocols.
		368	* @returns The found ICMP phone.
		369	* @returns ENOENT if the ICMP is not registered.
		370	*/
4707	mejdrech	371	int ip_get_icmp_phone( void );
4756	mejdrech	372
		373	/** Prepares the ICMP notification packet.
		374	* Releases additional packets and keeps only the first one.
		375	* @param[in] packet The packet or the packet queue to be reported as faulty.
		376	* @param[in] header The first packet IP header. May be NULL.
		377	* @returns EOK on success.
		378	* @returns EINVAL if there are no data in the packet.
		379	* @returns EINVAL if the packet is a fragment.
		380	* @returns ENOMEM if the packet is too short to contain the IP header.
		381	* @returns EAFNOSUPPORT if the address family is not supported.
		382	* @returns Other error codes as defined for the packet_set_addr().
		383	*/
4707	mejdrech	384	int ip_prepare_icmp( packet_t packet, ip_header_ref header );
		385
4756	mejdrech	386	/** Releases the packet and returns the result.
		387	* @param[in] packet The packet queue to be released.
		388	* @param[in] result The result to be returned.
		389	* @return The result parameter.
		390	*/
4711	mejdrech	391	int ip_release_and_return( packet_t packet, int result );
4707	mejdrech	392
4351	mejdrech	393	int ip_initialize( async_client_conn_t client_connection ){
4192	mejdrech	394	ERROR_DECLARE;
		395
4582	mejdrech	396	fibril_rwlock_initialize( & ip_globals.lock );
		397	fibril_rwlock_write_lock( & ip_globals.lock );
		398	fibril_rwlock_initialize( & ip_globals.protos_lock );
		399	fibril_rwlock_initialize( & ip_globals.netifs_lock );
4505	mejdrech	400	ip_globals.packet_counter = 0;
		401	ip_globals.gateway.address.s_addr = 0;
		402	ip_globals.gateway.netmask.s_addr = 0;
		403	ip_globals.gateway.gateway.s_addr = 0;
		404	ip_globals.gateway.netif = NULL;
4192	mejdrech	405	ERROR_PROPAGATE( ip_netifs_initialize( & ip_globals.netifs ));
		406	ERROR_PROPAGATE( ip_protos_initialize( & ip_globals.protos ));
4351	mejdrech	407	ip_globals.client_connection = client_connection;
4192	mejdrech	408	ERROR_PROPAGATE( modules_initialize( & ip_globals.modules ));
4307	mejdrech	409	ERROR_PROPAGATE( add_module( NULL, & ip_globals.modules, ARP_NAME, ARP_FILENAME, SERVICE_ARP, arp_task_get_id(), arp_connect_module ));
4582	mejdrech	410	fibril_rwlock_write_unlock( & ip_globals.lock );
3466	mejdrech	411	return EOK;
		412	}
		413
4350	mejdrech	414	int ip_device_req( int il_phone, device_id_t device_id, services_t netif ){
3666	mejdrech	415	ERROR_DECLARE;
		416
4505	mejdrech	417	ip_netif_ref ip_netif;
		418	ip_route_ref route;
		419	int index;
		420	char * data;
		421
		422	ip_netif = ( ip_netif_ref ) malloc( sizeof( ip_netif_t ));
		423	if( ! ip_netif ) return ENOMEM;
		424	if( ERROR_OCCURRED( ip_routes_initialize( & ip_netif->routes ))){
		425	free( ip_netif );
		426	return ERROR_CODE;
		427	}
		428	ip_netif->device_id = device_id;
		429	ip_netif->service = netif;
		430	ip_netif->state = NETIF_STOPPED;
4582	mejdrech	431	fibril_rwlock_write_lock( & ip_globals.netifs_lock );
4505	mejdrech	432	if( ERROR_OCCURRED( ip_netif_initialize( ip_netif ))){
4582	mejdrech	433	fibril_rwlock_write_unlock( & ip_globals.netifs_lock );
4505	mejdrech	434	ip_routes_destroy( & ip_netif->routes );
		435	free( ip_netif );
		436	return ERROR_CODE;
		437	}
		438	if( ip_netif->arp ) ++ ip_netif->arp->usage;
		439	// print the settings
		440	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 );
		441	printf( "\tconfiguration\t= %s\n", ip_netif->dhcp ? "dhcp" : "static" );
		442	// TODO ipv6 addresses
		443	data = ( char * ) malloc( INET_ADDRSTRLEN );
		444	if( data ){
		445	for( index = 0; index < ip_routes_count( & ip_netif->routes ); ++ index ){
		446	route = ip_routes_get_index( & ip_netif->routes, index );
		447	if( route ){
		448	printf( "\tRouting %d:\n", index );
		449	inet_ntop( AF_INET, ( uint8_t * ) & route->address.s_addr, data, INET_ADDRSTRLEN );
		450	printf( "\t\taddress\t= %s\n", data );
		451	inet_ntop( AF_INET, ( uint8_t * ) & route->netmask.s_addr, data, INET_ADDRSTRLEN );
		452	printf( "\t\tnetmask\t= %s\n", data );
		453	inet_ntop( AF_INET, ( uint8_t * ) & route->gateway.s_addr, data, INET_ADDRSTRLEN );
		454	printf( "\t\tgateway\t= %s\n", data );
		455	}
		456	}
		457	inet_ntop( AF_INET, ( uint8_t * ) & ip_netif->broadcast.s_addr, data, INET_ADDRSTRLEN );
4743	mejdrech	458	printf( "\t\tbroadcast\t= %s\n", data );
4505	mejdrech	459	free( data );
		460	}
4582	mejdrech	461	fibril_rwlock_write_unlock( & ip_globals.netifs_lock );
4505	mejdrech	462	return EOK;
		463	}
		464
		465	int ip_netif_initialize( ip_netif_ref ip_netif ){
		466	ERROR_DECLARE;
		467
4743	mejdrech	468	measured_string_t names[] = {{ "IPV", 3 }, { "IP_CONFIG", 9 }, { "IP_ADDR", 7 }, { "IP_NETMASK", 10 }, { "IP_GATEWAY", 10 }, { "IP_BROADCAST", 12 }, { "ARP", 3 }, { "IP_ROUTING", 10 }};
4307	mejdrech	469	measured_string_ref configuration;
4505	mejdrech	470	size_t count = sizeof( names ) / sizeof( measured_string_t );
4307	mejdrech	471	char * data;
4717	mejdrech	472	measured_string_t address;
4307	mejdrech	473	int index;
4505	mejdrech	474	ip_route_ref route;
		475	in_addr_t gateway;
3666	mejdrech	476
4702	mejdrech	477	ip_netif->arp = NULL;
4506	mejdrech	478	route = NULL;
4722	mejdrech	479	ip_netif->ipv = NET_DEFAULT_IPV;
		480	ip_netif->dhcp = false;
		481	ip_netif->routing = NET_DEFAULT_IP_ROUTING;
4307	mejdrech	482	configuration = & names[ 0 ];
3846	mejdrech	483	// get configuration
4307	mejdrech	484	ERROR_PROPAGATE( net_get_device_conf_req( ip_globals.net_phone, ip_netif->device_id, & configuration, count, & data ));
		485	if( configuration ){
		486	if( configuration[ 0 ].value ){
		487	ip_netif->ipv = strtol( configuration[ 0 ].value, NULL, 0 );
3846	mejdrech	488	}
4332	mejdrech	489	ip_netif->dhcp = ! str_lcmp( configuration[ 1 ].value, "dhcp", configuration[ 1 ].length );
3846	mejdrech	490	if( ip_netif->dhcp ){
		491	// TODO dhcp
4307	mejdrech	492	net_free_settings( configuration, data );
3846	mejdrech	493	return ENOTSUP;
4722	mejdrech	494	}else if( ip_netif->ipv == IPV4 ){
4505	mejdrech	495	route = ( ip_route_ref ) malloc( sizeof( ip_route_t ));
		496	if( ! route ){
		497	net_free_settings( configuration, data );
		498	return ENOMEM;
		499	}
		500	route->address.s_addr = 0;
		501	route->netmask.s_addr = 0;
		502	route->gateway.s_addr = 0;
		503	route->netif = ip_netif;
		504	index = ip_routes_add( & ip_netif->routes, route );
		505	if( index < 0 ){
		506	net_free_settings( configuration, data );
		507	free( route );
		508	return index;
		509	}
		510	if( ERROR_OCCURRED( inet_pton( AF_INET, configuration[ 2 ].value, ( uint8_t * ) & route->address.s_addr ))
		511	\|\| ERROR_OCCURRED( inet_pton( AF_INET, configuration[ 3 ].value, ( uint8_t * ) & route->netmask.s_addr ))
		512	\|\| ( inet_pton( AF_INET, configuration[ 4 ].value, ( uint8_t * ) & gateway.s_addr ) == EINVAL )
4743	mejdrech	513	\|\| ( inet_pton( AF_INET, configuration[ 5 ].value, ( uint8_t * ) & ip_netif->broadcast.s_addr ) == EINVAL )){
4307	mejdrech	514	net_free_settings( configuration, data );
3846	mejdrech	515	return EINVAL;
		516	}
		517	}else{
4505	mejdrech	518	// TODO ipv6 in separate module
4307	mejdrech	519	net_free_settings( configuration, data );
3846	mejdrech	520	return ENOTSUP;
		521	}
4743	mejdrech	522	if( configuration[ 6 ].value ){
		523	ip_netif->arp = get_running_module( & ip_globals.modules, configuration[ 6 ].value );
4192	mejdrech	524	if( ! ip_netif->arp ){
4743	mejdrech	525	printf( "Failed to start the arp %s\n", configuration[ 6 ].value );
4307	mejdrech	526	net_free_settings( configuration, data );
4192	mejdrech	527	return EINVAL;
		528	}
		529	}
4743	mejdrech	530	if( configuration[ 7 ].value ){
		531	ip_netif->routing = ( configuration[ 7 ].value[ 0 ] == 'y' );
4722	mejdrech	532	}
4307	mejdrech	533	net_free_settings( configuration, data );
3846	mejdrech	534	}
4717	mejdrech	535	// binds the netif service which also initializes the device
4743	mejdrech	536	ip_netif->phone = nil_bind_service( ip_netif->service, ( ipcarg_t ) ip_netif->device_id, SERVICE_IP, ip_globals.client_connection );
4192	mejdrech	537	if( ip_netif->phone < 0 ){
4505	mejdrech	538	printf( "Failed to contact the nil service %d\n", ip_netif->service );
4192	mejdrech	539	return ip_netif->phone;
		540	}
4717	mejdrech	541	// has to be after the device netif module initialization
4192	mejdrech	542	if( ip_netif->arp ){
4506	mejdrech	543	if( route ){
4717	mejdrech	544	address.value = ( char * ) & route->address.s_addr;
		545	address.length = CONVERT_SIZE( in_addr_t, char, 1 );
		546	ERROR_PROPAGATE( arp_device_req( ip_netif->arp->phone, ip_netif->device_id, SERVICE_IP, ip_netif->service, & address ));
4506	mejdrech	547	}else{
		548	ip_netif->arp = 0;
		549	}
4192	mejdrech	550	}
4505	mejdrech	551	// get packet dimensions
		552	ERROR_PROPAGATE( nil_packet_size_req( ip_netif->phone, ip_netif->device_id, & ip_netif->addr_len, & ip_netif->prefix, & ip_netif->content, & ip_netif->suffix ));
		553	if( ip_netif->content < IP_MIN_CONTENT ){
		554	printf( "Maximum transmission unit %d bytes is too small, at least %d bytes are needed\n", ip_netif->content, IP_MIN_CONTENT );
		555	ip_netif->content = IP_MIN_CONTENT;
		556	}
4192	mejdrech	557	index = ip_netifs_add( & ip_globals.netifs, ip_netif->device_id, ip_netif );
4505	mejdrech	558	if( index < 0 ) return index;
		559	if( gateway.s_addr ){
		560	// the default gateway
		561	ip_globals.gateway.address.s_addr = 0;
		562	ip_globals.gateway.netmask.s_addr = 0;
		563	ip_globals.gateway.gateway.s_addr = gateway.s_addr;
		564	ip_globals.gateway.netif = ip_netif;
4192	mejdrech	565	}
3846	mejdrech	566	return EOK;
		567	}
		568
4702	mejdrech	569	int ip_mtu_changed_message( device_id_t device_id, size_t mtu ){
4695	mejdrech	570	ip_netif_ref netif;
		571
		572	fibril_rwlock_write_lock( & ip_globals.netifs_lock );
		573	netif = ip_netifs_find( & ip_globals.netifs, device_id );
		574	if( ! netif ){
		575	fibril_rwlock_write_unlock( & ip_globals.netifs_lock );
		576	return ENOENT;
		577	}
		578	netif->content = mtu;
		579	printf( "ip - device %d changed mtu to %d\n\n", device_id, mtu );
		580	fibril_rwlock_write_unlock( & ip_globals.netifs_lock );
		581	return EOK;
		582	}
		583
4702	mejdrech	584	int ip_device_state_message( device_id_t device_id, device_state_t state ){
4243	mejdrech	585	ip_netif_ref netif;
		586
4582	mejdrech	587	fibril_rwlock_write_lock( & ip_globals.netifs_lock );
4731	mejdrech	588	// find the device
4243	mejdrech	589	netif = ip_netifs_find( & ip_globals.netifs, device_id );
4558	mejdrech	590	if( ! netif ){
4582	mejdrech	591	fibril_rwlock_write_unlock( & ip_globals.netifs_lock );
4558	mejdrech	592	return ENOENT;
		593	}
4505	mejdrech	594	netif->state = state;
4307	mejdrech	595	printf( "ip - device %d changed state to %d\n\n", device_id, state );
4582	mejdrech	596	fibril_rwlock_write_unlock( & ip_globals.netifs_lock );
4731	mejdrech	597	return EOK;
4307	mejdrech	598	}
		599
		600	int ip_connect_module( services_t service ){
		601	return EOK;
		602	}
		603
4558	mejdrech	604	int ip_bind_service( services_t service, int protocol, services_t me, async_client_conn_t receiver, tl_received_msg_t received_msg ){
		605	return ip_register( protocol, me, 0, received_msg );
4505	mejdrech	606	}
		607
4558	mejdrech	608	int ip_register( int protocol, services_t service, int phone, tl_received_msg_t received_msg ){
3846	mejdrech	609	ip_proto_ref proto;
4192	mejdrech	610	int index;
3846	mejdrech	611
4558	mejdrech	612	if( !( protocol && service && (( phone > 0 ) \|\| ( received_msg )))) return EINVAL;
3846	mejdrech	613	proto = ( ip_proto_ref ) malloc( sizeof( ip_protos_t ));
		614	if( ! proto ) return ENOMEM;
		615	proto->protocol = protocol;
4505	mejdrech	616	proto->service = service;
3846	mejdrech	617	proto->phone = phone;
4558	mejdrech	618	proto->received_msg = received_msg;
4582	mejdrech	619	fibril_rwlock_write_lock( & ip_globals.protos_lock );
4192	mejdrech	620	index = ip_protos_add( & ip_globals.protos, proto->protocol, proto );
		621	if( index < 0 ){
4582	mejdrech	622	fibril_rwlock_write_unlock( & ip_globals.protos_lock );
3846	mejdrech	623	free( proto );
4192	mejdrech	624	return index;
3846	mejdrech	625	}
4307	mejdrech	626	printf( "New protocol registered:\n\tprotocol\t= %d\n\tphone\t= %d\n", proto->protocol, proto->phone );
4582	mejdrech	627	fibril_rwlock_write_unlock( & ip_globals.protos_lock );
3846	mejdrech	628	return EOK;
		629	}
		630
4707	mejdrech	631	int ip_send_msg( int il_phone, device_id_t device_id, packet_t packet, services_t sender, services_t error ){
4505	mejdrech	632	ERROR_DECLARE;
		633
4720	mejdrech	634	int addrlen;
4505	mejdrech	635	ip_netif_ref netif;
		636	ip_route_ref route;
4720	mejdrech	637	struct sockaddr * addr;
		638	struct sockaddr_in * address_in;
		639	// struct sockaddr_in6 * address_in6;
4575	mejdrech	640	in_addr_t * dest;
4505	mejdrech	641	in_addr_t * src;
4707	mejdrech	642	int phone;
4505	mejdrech	643
		644	// addresses in the host byte order
		645	// should be the next hop address or the target destination address
4720	mejdrech	646	addrlen = packet_get_addr( packet, NULL, ( uint8_t ** ) & addr );
		647	if( addrlen < 0 ){
		648	return ip_release_and_return( packet, addrlen );
4505	mejdrech	649	}
4743	mejdrech	650	if(( size_t ) addrlen < sizeof( struct sockaddr )){
4711	mejdrech	651	return ip_release_and_return( packet, EINVAL );
4505	mejdrech	652	}
4720	mejdrech	653	switch( addr->sa_family ){
		654	case AF_INET:
		655	if( addrlen != sizeof( struct sockaddr_in )){
		656	return ip_release_and_return( packet, EINVAL );
		657	}
		658	address_in = ( struct sockaddr_in * ) addr;
		659	dest = & address_in->sin_addr;
		660	break;
		661	// TODO IPv6
		662	/* case AF_INET6:
		663	if( addrlen != sizeof( struct sockaddr_in6 )) return EINVAL;
		664	address_in6 = ( struct sockaddr_in6 * ) dest;
		665	address_in6.sin6_addr.s6_addr;
		666	*/ default:
		667	return ip_release_and_return( packet, EAFNOSUPPORT );
		668	}
4582	mejdrech	669	fibril_rwlock_read_lock( & ip_globals.netifs_lock );
4505	mejdrech	670	// device specified?
4575	mejdrech	671	if( device_id > 0 ){
4505	mejdrech	672	netif = ip_netifs_find( & ip_globals.netifs, device_id );
4575	mejdrech	673	route = ip_netif_find_route( netif, * dest );
4735	mejdrech	674	if( netif && ( ! route ) && ( ip_globals.gateway.netif == netif )){
		675	route = & ip_globals.gateway;
		676	}
4505	mejdrech	677	}else{
4575	mejdrech	678	route = ip_find_route( * dest );
4505	mejdrech	679	netif = route ? route->netif : NULL;
		680	}
		681	if( !( netif && route )){
4582	mejdrech	682	fibril_rwlock_read_unlock( & ip_globals.netifs_lock );
4707	mejdrech	683	phone = ip_prepare_icmp_and_get_phone( error, packet, NULL );
		684	if( phone >= 0 ){
		685	// unreachable ICMP if no routing
4724	mejdrech	686	icmp_destination_unreachable_msg( phone, ICMP_NET_UNREACH, 0, packet );
4707	mejdrech	687	}
4505	mejdrech	688	return ENOENT;
		689	}
4707	mejdrech	690	if( error ){
		691	// do not send for broadcast, anycast packets or network broadcast
		692	if(( ! dest->s_addr )
		693	\|\| ( !( ~ dest->s_addr ))
		694	\|\| ( !( ~(( dest->s_addr & ( ~ route->netmask.s_addr )) \| route->netmask.s_addr )))
		695	\|\| ( !( dest->s_addr & ( ~ route->netmask.s_addr )))){
4711	mejdrech	696	return ip_release_and_return( packet, EINVAL );
4707	mejdrech	697	}
		698	}
4724	mejdrech	699	if( route->address.s_addr == dest->s_addr ){
		700	// find the loopback device to deliver
		701	dest->s_addr = IPV4_LOCALHOST_ADDRESS;
		702	route = ip_find_route( * dest );
		703	netif = route ? route->netif : NULL;
		704	if( !( netif && route )){
		705	fibril_rwlock_read_unlock( & ip_globals.netifs_lock );
		706	phone = ip_prepare_icmp_and_get_phone( error, packet, NULL );
		707	if( phone >= 0 ){
		708	// unreachable ICMP if no routing
		709	icmp_destination_unreachable_msg( phone, ICMP_HOST_UNREACH, 0, packet );
		710	}
		711	return ENOENT;
		712	}
		713	}
4707	mejdrech	714	src = ip_netif_address( netif );
4505	mejdrech	715	if( ! src ){
4582	mejdrech	716	fibril_rwlock_read_unlock( & ip_globals.netifs_lock );
4711	mejdrech	717	return ip_release_and_return( packet, ENOENT );
4505	mejdrech	718	}
4720	mejdrech	719	ERROR_CODE = ip_send_route( packet, netif, route, src, * dest, error );
4582	mejdrech	720	fibril_rwlock_read_unlock( & ip_globals.netifs_lock );
4505	mejdrech	721	return ERROR_CODE;
		722	}
		723
4707	mejdrech	724	in_addr_t * ip_netif_address( ip_netif_ref netif ){
4505	mejdrech	725	ip_route_ref route;
		726
		727	route = ip_routes_get_index( & netif->routes, 0 );
		728	return route ? & route->address : NULL;
		729	}
		730
4707	mejdrech	731	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 ){
4505	mejdrech	732	ERROR_DECLARE;
		733
		734	measured_string_t destination;
		735	measured_string_ref translation;
		736	char * data;
4707	mejdrech	737	int phone;
4505	mejdrech	738
		739	// get destination hardware address
4722	mejdrech	740	if( netif->arp && ( route->address.s_addr != dest.s_addr )){
4575	mejdrech	741	destination.value = route->gateway.s_addr ? ( char * ) & route->gateway.s_addr : ( char * ) & dest.s_addr;
4505	mejdrech	742	destination.length = CONVERT_SIZE( dest.s_addr, char, 1 );
		743	if( ERROR_OCCURRED( arp_translate_req( netif->arp->phone, netif->device_id, SERVICE_IP, & destination, & translation, & data ))){
4720	mejdrech	744	// sleep( 1 );
		745	// ERROR_PROPAGATE( arp_translate_req( netif->arp->phone, netif->device_id, SERVICE_IP, & destination, & translation, & data ));
		746	pq_release( ip_globals.net_phone, packet_get_id( packet ));
		747	return ERROR_CODE;
4505	mejdrech	748	}
4707	mejdrech	749	if( !( translation && translation->value )){
		750	if( translation ){
		751	free( translation );
		752	free( data );
		753	}
		754	phone = ip_prepare_icmp_and_get_phone( error, packet, NULL );
		755	if( phone >= 0 ){
		756	// unreachable ICMP if no routing
		757	icmp_destination_unreachable_msg( phone, ICMP_HOST_UNREACH, 0, packet );
		758	}
4505	mejdrech	759	return EINVAL;
		760	}
		761	}else translation = NULL;
4589	mejdrech	762	if( ERROR_OCCURRED( ip_prepare_packet( src, dest, packet, translation ))){
		763	pq_release( ip_globals.net_phone, packet_get_id( packet ));
		764	}else{
4707	mejdrech	765	packet = ip_split_packet( packet, netif->prefix, netif->content, netif->suffix, netif->addr_len, error );
4589	mejdrech	766	if( packet ){
		767	nil_send_msg( netif->phone, netif->device_id, packet, SERVICE_IP );
4505	mejdrech	768	}
4589	mejdrech	769	}
4505	mejdrech	770	if( translation ){
		771	free( translation );
		772	free( data );
		773	}
4589	mejdrech	774	return ERROR_CODE;
3846	mejdrech	775	}
		776
4575	mejdrech	777	int ip_prepare_packet( in_addr_t * source, in_addr_t dest, packet_t packet, measured_string_ref destination ){
4505	mejdrech	778	ERROR_DECLARE;
		779
4558	mejdrech	780	size_t length;
4505	mejdrech	781	ip_header_ref header;
4589	mejdrech	782	ip_header_ref last_header;
		783	ip_header_ref middle_header;
		784	packet_t next;
4505	mejdrech	785
		786	length = packet_get_data_length( packet );
		787	if(( length < sizeof( ip_header_t )) \|\| ( length > IP_MAX_CONTENT )) return EINVAL;
		788	header = ( ip_header_ref ) packet_get_data( packet );
		789	if( destination ){
		790	ERROR_PROPAGATE( packet_set_addr( packet, NULL, ( uint8_t * ) destination->value, CONVERT_SIZE( char, uint8_t, destination->length )));
4722	mejdrech	791	}else{
		792	ERROR_PROPAGATE( packet_set_addr( packet, NULL, NULL, 0 ));
4505	mejdrech	793	}
4722	mejdrech	794	header->version = IPV4;
4731	mejdrech	795	header->fragment_offset_high = 0;
		796	header->fragment_offset_low = 0;
4589	mejdrech	797	header->header_checksum = 0;
4575	mejdrech	798	if( source ) header->source_address = source->s_addr;
		799	header->destination_address = dest.s_addr;
4582	mejdrech	800	fibril_rwlock_write_lock( & ip_globals.lock );
4505	mejdrech	801	++ ip_globals.packet_counter;
		802	header->identification = htons( ip_globals.packet_counter );
4582	mejdrech	803	fibril_rwlock_write_unlock( & ip_globals.lock );
4731	mejdrech	804	// length = packet_get_data_length( packet );
4589	mejdrech	805	if( pq_next( packet )){
		806	last_header = ( ip_header_ref ) malloc( IP_HEADER_LENGTH( header ));
		807	if( ! last_header ) return ENOMEM;
		808	ip_create_last_header( last_header, header );
		809	next = pq_next( packet );
		810	while( pq_next( next )){
		811	middle_header = ( ip_header_ref ) packet_prefix( next, IP_HEADER_LENGTH( last_header ));
		812	if( ! middle_header ) return ENOMEM;
		813	memcpy( middle_header, last_header, IP_HEADER_LENGTH( last_header ));
		814	header->flags \|= IPFLAG_MORE_FRAGMENTS;
		815	middle_header->total_length = htons( packet_get_data_length( next ));
4731	mejdrech	816	middle_header->fragment_offset_high = IP_COMPUTE_FRAGMENT_OFFSET_HIGH( length );
		817	middle_header->fragment_offset_low = IP_COMPUTE_FRAGMENT_OFFSET_LOW( length );
4589	mejdrech	818	middle_header->header_checksum = IP_HEADER_CHECKSUM( middle_header );
		819	if( destination ){
		820	ERROR_PROPAGATE( packet_set_addr( next, NULL, ( uint8_t * ) destination->value, CONVERT_SIZE( char, uint8_t, destination->length )));
		821	}
		822	length += packet_get_data_length( next );
		823	next = pq_next( next );
		824	}
		825	middle_header = ( ip_header_ref ) packet_prefix( next, IP_HEADER_LENGTH( last_header ));
		826	if( ! middle_header ) return ENOMEM;
		827	memcpy( middle_header, last_header, IP_HEADER_LENGTH( last_header ));
		828	middle_header->total_length = htons( packet_get_data_length( next ));
4731	mejdrech	829	middle_header->fragment_offset_high = IP_COMPUTE_FRAGMENT_OFFSET_HIGH( length );
		830	middle_header->fragment_offset_low = IP_COMPUTE_FRAGMENT_OFFSET_LOW( length );
4589	mejdrech	831	middle_header->header_checksum = IP_HEADER_CHECKSUM( middle_header );
		832	if( destination ){
		833	ERROR_PROPAGATE( packet_set_addr( next, NULL, ( uint8_t * ) destination->value, CONVERT_SIZE( char, uint8_t, destination->length )));
		834	}
		835	length += packet_get_data_length( next );
		836	free( last_header );
		837	header->flags \|= IPFLAG_MORE_FRAGMENTS;
		838	}
		839	header->total_length = htons( length );
4505	mejdrech	840	// unnecessary for all protocols
		841	header->header_checksum = IP_HEADER_CHECKSUM( header );
		842	return EOK;
		843	}
		844
3846	mejdrech	845	int ip_message( ipc_callid_t callid, ipc_call_t * call, ipc_call_t * answer, int * answer_count ){
		846	ERROR_DECLARE;
		847
4722	mejdrech	848	packet_t packet;
		849	struct sockaddr * addr;
		850	size_t addrlen;
		851	ip_pseudo_header_ref header;
		852	size_t headerlen;
3846	mejdrech	853
		854	* answer_count = 0;
		855	switch( IPC_GET_METHOD( * call )){
3466	mejdrech	856	case IPC_M_PHONE_HUNGUP:
		857	return EOK;
3666	mejdrech	858	case NET_IL_DEVICE:
4307	mejdrech	859	return ip_device_req( 0, IPC_GET_DEVICE( call ), IPC_GET_SERVICE( call ));
3846	mejdrech	860	case IPC_M_CONNECT_TO_ME:
4505	mejdrech	861	return ip_register( IL_GET_PROTO( call ), IL_GET_SERVICE( call ), IPC_GET_PHONE( call ), NULL );
4307	mejdrech	862	case NET_IL_SEND:
		863	ERROR_PROPAGATE( packet_translate( ip_globals.net_phone, & packet, IPC_GET_PACKET( call )));
4707	mejdrech	864	return ip_send_msg( 0, IPC_GET_DEVICE( call ), packet, 0, IPC_GET_ERROR( call ));
4351	mejdrech	865	case NET_IL_DEVICE_STATE:
4702	mejdrech	866	return ip_device_state_message( IPC_GET_DEVICE( call ), IPC_GET_STATE( call ));
4351	mejdrech	867	case NET_IL_RECEIVED:
		868	ERROR_PROPAGATE( packet_translate( ip_globals.net_phone, & packet, IPC_GET_PACKET( call )));
4702	mejdrech	869	return ip_receive_message( IPC_GET_DEVICE( call ), packet );
4707	mejdrech	870	case NET_IP_RECEIVED_ERROR:
		871	ERROR_PROPAGATE( packet_translate( ip_globals.net_phone, & packet, IPC_GET_PACKET( call )));
		872	return ip_received_error_msg( 0, IPC_GET_DEVICE( call ), packet, IPC_GET_TARGET( call ), IPC_GET_ERROR( call ));
4505	mejdrech	873	case NET_IP_ADD_ROUTE:
		874	return ip_add_route_req( 0, IPC_GET_DEVICE( call ), IP_GET_ADDRESS( call ), IP_GET_NETMASK( call ), IP_GET_GATEWAY( call ));
		875	case NET_IP_SET_GATEWAY:
		876	return ip_set_gateway_req( 0, IPC_GET_DEVICE( call ), IP_GET_GATEWAY( call ));
4722	mejdrech	877	case NET_IP_GET_ROUTE:
		878	ERROR_PROPAGATE( data_receive(( void ** ) & addr, & addrlen ));
		879	ERROR_PROPAGATE( ip_get_route_req( 0, IP_GET_PROTOCOL( call ), addr, ( socklen_t ) addrlen, IPC_SET_DEVICE( answer ), & header, & headerlen ));
		880	* IP_SET_HEADERLEN( answer ) = headerlen;
4735	mejdrech	881	* answer_count = 2;
4722	mejdrech	882	if( ! ERROR_OCCURRED( data_reply( & headerlen, sizeof( headerlen )))){
		883	ERROR_CODE = data_reply( header, headerlen );
		884	}
		885	free( header );
		886	return ERROR_CODE;
4505	mejdrech	887	case NET_IL_PACKET_SPACE:
		888	ERROR_PROPAGATE( ip_packet_size_req( 0, IPC_GET_DEVICE( call ), IPC_SET_ADDR( answer ), IPC_SET_PREFIX( answer ), IPC_SET_CONTENT( answer ), IPC_SET_SUFFIX( answer )));
		889	* answer_count = 3;
		890	return EOK;
4695	mejdrech	891	case NET_IL_MTU_CHANGED:
4702	mejdrech	892	return ip_mtu_changed_message( IPC_GET_DEVICE( call ), IPC_GET_MTU( call ));
3466	mejdrech	893	}
		894	return ENOTSUP;
		895	}
		896
4505	mejdrech	897	int ip_packet_size_req( int ip_phone, device_id_t device_id, size_t * addr_len, size_t * prefix, size_t * content, size_t * suffix ){
		898	ip_netif_ref netif;
4575	mejdrech	899	int index;
4505	mejdrech	900
		901	if( !( addr_len && prefix && content && suffix )) return EBADMEM;
4575	mejdrech	902	* content = IP_MAX_CONTENT - IP_PREFIX;
4582	mejdrech	903	fibril_rwlock_read_lock( & ip_globals.netifs_lock );
4575	mejdrech	904	if( device_id < 0 ){
		905	* addr_len = IP_ADDR;
		906	* prefix = 0;
		907	* suffix = 0;
		908	for( index = ip_netifs_count( & ip_globals.netifs ) - 1; index >= 0; -- index ){
		909	netif = ip_netifs_get_index( & ip_globals.netifs, index );
		910	if( netif ){
		911	if( netif->addr_len > * addr_len ) * addr_len = netif->addr_len;
		912	if( netif->prefix > * prefix ) * prefix = netif->prefix;
		913	if( netif->suffix > * suffix ) * suffix = netif->suffix;
		914	}
		915	}
		916	* prefix = * prefix + IP_PREFIX;
		917	* suffix = * suffix + IP_SUFFIX;
		918	}else{
		919	netif = ip_netifs_find( & ip_globals.netifs, device_id );
		920	if( ! netif ){
4582	mejdrech	921	fibril_rwlock_read_unlock( & ip_globals.netifs_lock );
4575	mejdrech	922	return ENOENT;
		923	}
		924	* addr_len = ( netif->addr_len > IP_ADDR ) ? netif->addr_len : IP_ADDR;
		925	* prefix = netif->prefix + IP_PREFIX;
		926	* suffix = netif->suffix + IP_SUFFIX;
4505	mejdrech	927	}
4582	mejdrech	928	fibril_rwlock_read_unlock( & ip_globals.netifs_lock );
4505	mejdrech	929	return EOK;
		930	}
		931
		932	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 ){
		933	ip_route_ref route;
		934	ip_netif_ref netif;
		935	int index;
		936
4582	mejdrech	937	fibril_rwlock_write_lock( & ip_globals.netifs_lock );
4505	mejdrech	938	netif = ip_netifs_find( & ip_globals.netifs, device_id );
4558	mejdrech	939	if( ! netif ){
4582	mejdrech	940	fibril_rwlock_write_unlock( & ip_globals.netifs_lock );
4558	mejdrech	941	return ENOENT;
		942	}
4505	mejdrech	943	route = ( ip_route_ref ) malloc( sizeof( ip_route_t ));
4558	mejdrech	944	if( ! route ){
4582	mejdrech	945	fibril_rwlock_write_unlock( & ip_globals.netifs_lock );
4558	mejdrech	946	return ENOMEM;
		947	}
4505	mejdrech	948	route->address.s_addr = address.s_addr;
		949	route->netmask.s_addr = netmask.s_addr;
		950	route->gateway.s_addr = gateway.s_addr;
		951	route->netif = netif;
		952	index = ip_routes_add( & netif->routes, route );
		953	if( index < 0 ) free( route );
4582	mejdrech	954	fibril_rwlock_write_unlock( & ip_globals.netifs_lock );
4505	mejdrech	955	return index;
		956	}
		957
		958	ip_route_ref ip_find_route( in_addr_t destination ){
		959	int index;
		960	ip_route_ref route;
		961	ip_netif_ref netif;
		962
		963	// start with the last netif - the newest one
		964	index = ip_netifs_count( & ip_globals.netifs ) - 1;
		965	while( index >= 0 ){
		966	netif = ip_netifs_get_index( & ip_globals.netifs, index );
		967	if( netif && ( netif->state == NETIF_ACTIVE )){
		968	route = ip_netif_find_route( netif, destination );
		969	if( route ) return route;
		970	}
		971	-- index;
		972	}
		973	return & ip_globals.gateway;
		974	}
		975
		976	ip_route_ref ip_netif_find_route( ip_netif_ref netif, in_addr_t destination ){
		977	int index;
		978	ip_route_ref route;
		979
		980	if( netif ){
		981	// start with the first one - the direct route
		982	for( index = 0; index < ip_routes_count( & netif->routes ); ++ index ){
		983	route = ip_routes_get_index( & netif->routes, index );
		984	if( route && (( route->address.s_addr & route->netmask.s_addr ) == ( destination.s_addr & route->netmask.s_addr ))){
		985	return route;
		986	}
		987	}
		988	}
		989	return NULL;
		990	}
		991
		992	int ip_set_gateway_req( int ip_phone, device_id_t device_id, in_addr_t gateway ){
		993	ip_netif_ref netif;
		994
4582	mejdrech	995	fibril_rwlock_write_lock( & ip_globals.netifs_lock );
4505	mejdrech	996	netif = ip_netifs_find( & ip_globals.netifs, device_id );
4558	mejdrech	997	if( ! netif ){
4582	mejdrech	998	fibril_rwlock_write_unlock( & ip_globals.netifs_lock );
4558	mejdrech	999	return ENOENT;
		1000	}
4505	mejdrech	1001	ip_globals.gateway.address.s_addr = 0;
		1002	ip_globals.gateway.netmask.s_addr = 0;
		1003	ip_globals.gateway.gateway.s_addr = gateway.s_addr;
		1004	ip_globals.gateway.netif = netif;
4582	mejdrech	1005	fibril_rwlock_write_unlock( & ip_globals.netifs_lock );
4505	mejdrech	1006	return EOK;
		1007	}
		1008
4720	mejdrech	1009	packet_t ip_split_packet( packet_t packet, size_t prefix, size_t content, size_t suffix, socklen_t addr_len, services_t error ){
4505	mejdrech	1010	size_t length;
		1011	packet_t next;
		1012	packet_t new_packet;
4707	mejdrech	1013	int result;
		1014	int phone;
4505	mejdrech	1015
		1016	next = packet;
		1017	// check all packets
		1018	while( next ){
		1019	length = packet_get_data_length( next );
		1020	// too long?
		1021	if( length > content ){
4707	mejdrech	1022	result = ip_fragment_packet( next, content, prefix, suffix, addr_len );
		1023	if( result != EOK ){
4505	mejdrech	1024	new_packet = pq_detach( next );
		1025	if( next == packet ){
4707	mejdrech	1026	// the new first packet of the queue
4505	mejdrech	1027	packet = new_packet;
		1028	}
4707	mejdrech	1029	// fragmentation needed?
		1030	if( result == EPERM ){
		1031	phone = ip_prepare_icmp_and_get_phone( error, next, NULL );
		1032	if( phone >= 0 ){
		1033	// fragmentation necessary ICMP
		1034	icmp_destination_unreachable_msg( phone, ICMP_FRAG_NEEDED, content, next );
		1035	}
		1036	}else{
		1037	pq_release( ip_globals.net_phone, packet_get_id( next ));
		1038	}
4505	mejdrech	1039	next = new_packet;
		1040	continue;
		1041	}
		1042	}
		1043	next = pq_next( next );
		1044	}
		1045	return packet;
		1046	}
		1047
4720	mejdrech	1048	int ip_fragment_packet( packet_t packet, size_t length, size_t prefix, size_t suffix, socklen_t addr_len ){
4505	mejdrech	1049	ERROR_DECLARE;
		1050
		1051	packet_t new_packet;
		1052	ip_header_ref header;
		1053	ip_header_ref middle_header;
		1054	ip_header_ref last_header;
4720	mejdrech	1055	struct sockaddr * src;
		1056	struct sockaddr * dest;
		1057	socklen_t addrlen;
4708	mejdrech	1058	int result;
4505	mejdrech	1059
4720	mejdrech	1060	result = packet_get_addr( packet, ( uint8_t ) & src, ( uint8_t ) & dest );
4708	mejdrech	1061	if( result <= 0 ) return EINVAL;
4720	mejdrech	1062	addrlen = ( socklen_t ) result;
4505	mejdrech	1063	if( packet_get_data_length( packet ) <= sizeof( ip_header_t )) return ENOMEM;
		1064	// get header
		1065	header = ( ip_header_ref ) packet_get_data( packet );
		1066	if( ! header ) return EINVAL;
		1067	// fragmentation forbidden?
		1068	if( header->flags & IPFLAG_DONT_FRAGMENT ){
		1069	return EPERM;
		1070	}
		1071	// create the last fragment
4720	mejdrech	1072	new_packet = packet_get_4( ip_globals.net_phone, prefix, length, suffix, (( addrlen > addr_len ) ? addrlen : addr_len ));
4505	mejdrech	1073	if( ! new_packet ) return ENOMEM;
4589	mejdrech	1074	// allocate as much as originally
		1075	last_header = ( ip_header_ref ) packet_suffix( new_packet, IP_HEADER_LENGTH( header ));
4505	mejdrech	1076	if( ! last_header ){
4711	mejdrech	1077	return ip_release_and_return( packet, ENOMEM );
4505	mejdrech	1078	}
4589	mejdrech	1079	ip_create_last_header( last_header, header );
		1080	// trim the unused space
		1081	if( ERROR_OCCURRED( packet_trim( new_packet, 0, IP_HEADER_LENGTH( header ) - IP_HEADER_LENGTH( last_header )))){
4711	mejdrech	1082	return ip_release_and_return( packet, ERROR_CODE );
4589	mejdrech	1083	}
4505	mejdrech	1084	// biggest multiple of 8 lower than content
		1085	// TODO even fragmentation?
		1086	length = length & ( ~ 0x7 );// ( content / 8 ) * 8
4731	mejdrech	1087	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 ))){
4711	mejdrech	1088	return ip_release_and_return( packet, ERROR_CODE );
4505	mejdrech	1089	}
		1090	// mark the first as fragmented
		1091	header->flags \|= IPFLAG_MORE_FRAGMENTS;
		1092	// create middle framgents
		1093	while( IP_TOTAL_LENGTH( header ) > length ){
4720	mejdrech	1094	new_packet = packet_get_4( ip_globals.net_phone, prefix, length, suffix, (( addrlen >= addr_len ) ? addrlen : addr_len ));
4505	mejdrech	1095	if( ! new_packet ) return ENOMEM;
		1096	middle_header = ip_create_middle_header( new_packet, last_header );
		1097	if( ! middle_header ){
4711	mejdrech	1098	return ip_release_and_return( packet, ENOMEM );
4505	mejdrech	1099	}
4731	mejdrech	1100	if( ERROR_OCCURRED( ip_fragment_packet_data( packet, new_packet, header, middle_header, ( length - IP_HEADER_LENGTH( middle_header )) & ( ~ 0x7 ), src, dest, addrlen ))){
4711	mejdrech	1101	return ip_release_and_return( packet, ERROR_CODE );
4505	mejdrech	1102	}
		1103	}
		1104	// finish the first fragment
		1105	header->header_checksum = IP_HEADER_CHECKSUM( header );
		1106	return EOK;
		1107	}
		1108
4720	mejdrech	1109	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 ){
4505	mejdrech	1110	ERROR_DECLARE;
		1111
		1112	void * data;
4731	mejdrech	1113	size_t offset;
4505	mejdrech	1114
		1115	data = packet_suffix( new_packet, length );
		1116	if( ! data ) return ENOMEM;
		1117	memcpy( data, (( void * ) header ) + IP_TOTAL_LENGTH( header ) - length, length );
		1118	ERROR_PROPAGATE( packet_trim( packet, 0, length ));
		1119	header->total_length = htons( IP_TOTAL_LENGTH( header ) - length );
		1120	new_header->total_length = htons( IP_HEADER_LENGTH( new_header ) + length );
4731	mejdrech	1121	offset = IP_FRAGMENT_OFFSET( header ) + IP_HEADER_DATA_LENGTH( header );
		1122	new_header->fragment_offset_high = IP_COMPUTE_FRAGMENT_OFFSET_HIGH( offset );
		1123	new_header->fragment_offset_low = IP_COMPUTE_FRAGMENT_OFFSET_LOW( offset );
4505	mejdrech	1124	new_header->header_checksum = IP_HEADER_CHECKSUM( new_header );
4720	mejdrech	1125	ERROR_PROPAGATE( packet_set_addr( new_packet, ( const uint8_t * ) src, ( const uint8_t * ) dest, addrlen ));
4505	mejdrech	1126	return pq_insert_after( packet, new_packet );
		1127	}
		1128
		1129	ip_header_ref ip_create_middle_header( packet_t packet, ip_header_ref last ){
		1130	ip_header_ref middle;
		1131
		1132	middle = ( ip_header_ref ) packet_suffix( packet, IP_HEADER_LENGTH( last ));
		1133	if( ! middle ) return NULL;
		1134	memcpy( middle, last, IP_HEADER_LENGTH( last ));
		1135	middle->flags \|= IPFLAG_MORE_FRAGMENTS;
		1136	return middle;
		1137	}
		1138
4589	mejdrech	1139	void ip_create_last_header( ip_header_ref last, ip_header_ref first ){
4505	mejdrech	1140	ip_option_ref option;
		1141	size_t next;
		1142	size_t length;
		1143
		1144	// copy first itself
		1145	memcpy( last, first, sizeof( ip_header_t ));
		1146	length = sizeof( ip_header_t );
		1147	next = sizeof( ip_header_t );
		1148	// process all ip options
4728	mejdrech	1149	while( next < first->header_length ){
4708	mejdrech	1150	option = ( ip_option_ref ) ((( uint8_t * ) first ) + next );
4505	mejdrech	1151	// skip end or noop
		1152	if(( option->type == IPOPT_END ) \|\| ( option->type == IPOPT_NOOP )){
		1153	++ next;
		1154	}else{
		1155	// copy if said so or skip
		1156	if( IPOPT_COPIED( option->type )){
4708	mejdrech	1157	memcpy((( uint8_t * ) last ) + length, (( uint8_t * ) first ) + next, option->length );
4505	mejdrech	1158	length += option->length;
		1159	}
		1160	// next option
		1161	next += option->length;
		1162	}
		1163	}
		1164	// align 4 byte boundary
		1165	if( length % 4 ){
4708	mejdrech	1166	bzero((( uint8_t * ) last ) + length, 4 - ( length % 4 ));
4728	mejdrech	1167	last->header_length = length / 4 + 1;
4505	mejdrech	1168	}else{
4728	mejdrech	1169	last->header_length = length / 4;
4505	mejdrech	1170	}
4589	mejdrech	1171	last->header_checksum = 0;
4505	mejdrech	1172	}
		1173
4702	mejdrech	1174	int ip_receive_message( device_id_t device_id, packet_t packet ){
4505	mejdrech	1175	packet_t next;
		1176
		1177	do{
		1178	next = pq_detach( packet );
4707	mejdrech	1179	ip_process_packet( device_id, packet );
4505	mejdrech	1180	packet = next;
		1181	}while( packet );
		1182	return EOK;
		1183	}
		1184
		1185	int ip_process_packet( device_id_t device_id, packet_t packet ){
		1186	ERROR_DECLARE;
		1187
		1188	ip_header_ref header;
		1189	in_addr_t dest;
		1190	ip_route_ref route;
4707	mejdrech	1191	int phone;
4720	mejdrech	1192	struct sockaddr * addr;
		1193	struct sockaddr_in addr_in;
		1194	// struct sockaddr_in addr_in6;
		1195	socklen_t addrlen;
4505	mejdrech	1196
		1197	header = ( ip_header_ref ) packet_get_data( packet );
4707	mejdrech	1198	if( ! header ){
4711	mejdrech	1199	return ip_release_and_return( packet, ENOMEM );
4707	mejdrech	1200	}
4505	mejdrech	1201	// checksum
		1202	if(( header->header_checksum ) && ( IP_HEADER_CHECKSUM( header ))){
4731	mejdrech	1203	phone = ip_prepare_icmp_and_get_phone( 0, packet, header );
		1204	if( phone >= 0 ){
		1205	// checksum error ICMP
		1206	icmp_parameter_problem_msg( phone, ICMP_PARAM_POINTER, (( size_t ) (( void * ) & header->header_checksum )) - (( size_t ) (( void * ) header )), packet );
		1207	}
		1208	return EINVAL;
4707	mejdrech	1209	}
		1210	if( header->ttl <= 1 ){
		1211	phone = ip_prepare_icmp_and_get_phone( 0, packet, header );
		1212	if( phone >= 0 ){
		1213	// ttl oxceeded ICMP
		1214	icmp_time_exceeded_msg( phone, ICMP_EXC_TTL, packet );
		1215	}
4505	mejdrech	1216	return EINVAL;
		1217	}
		1218	// process ipopt and get destination
		1219	dest = ip_get_destination( header );
4720	mejdrech	1220	// set the addrination address
		1221	switch( header->version ){
		1222	case IPVERSION:
		1223	addrlen = sizeof( addr_in );
		1224	bzero( & addr_in, addrlen );
		1225	addr_in.sin_family = AF_INET;
		1226	memcpy( & addr_in.sin_addr.s_addr, & dest, sizeof( dest ));
		1227	addr = ( struct sockaddr * ) & addr_in;
		1228	break;
		1229	/* case IPv6VERSION:
		1230	addrlen = sizeof( dest_in6 );
		1231	bzero( & dest_in6, addrlen );
		1232	dest_in6.sin6_family = AF_INET6;
		1233	memcpy( & dest_in6.sin6_addr.s6_addr, );
		1234	dest = ( struct sockaddr * ) & dest_in;
		1235	break;
		1236	*/ default:
4756	mejdrech	1237	return ip_release_and_return( packet, EAFNOSUPPORT );
4720	mejdrech	1238	}
		1239	ERROR_PROPAGATE( packet_set_addr( packet, NULL, ( uint8_t * ) & addr, addrlen ));
4505	mejdrech	1240	route = ip_find_route( dest );
4707	mejdrech	1241	if( ! route ){
		1242	phone = ip_prepare_icmp_and_get_phone( 0, packet, header );
		1243	if( phone >= 0 ){
		1244	// unreachable ICMP
		1245	icmp_destination_unreachable_msg( phone, ICMP_HOST_UNREACH, 0, packet );
		1246	}
		1247	return ENOENT;
		1248	}
4505	mejdrech	1249	if( route->address.s_addr == dest.s_addr ){
		1250	// local delivery
4707	mejdrech	1251	return ip_deliver_local( device_id, packet, header, 0 );
4505	mejdrech	1252	}else{
4695	mejdrech	1253	// only if routing enabled
		1254	if( route->netif->routing ){
4707	mejdrech	1255	-- header->ttl;
		1256	return ip_send_route( packet, route->netif, route, NULL, dest, 0 );
		1257	}else{
		1258	phone = ip_prepare_icmp_and_get_phone( 0, packet, header );
		1259	if( phone >= 0 ){
		1260	// unreachable ICMP if no routing
		1261	icmp_destination_unreachable_msg( phone, ICMP_HOST_UNREACH, 0, packet );
		1262	}
4695	mejdrech	1263	return ENOENT;
		1264	}
4505	mejdrech	1265	}
		1266	}
		1267
4707	mejdrech	1268	int ip_received_error_msg( int ip_phone, device_id_t device_id, packet_t packet, services_t target, services_t error ){
		1269	uint8_t * data;
		1270	int offset;
		1271	icmp_type_t type;
		1272	icmp_code_t code;
		1273	ip_netif_ref netif;
		1274	measured_string_t address;
		1275	ip_route_ref route;
		1276	ip_header_ref header;
		1277
		1278	switch( error ){
		1279	case SERVICE_ICMP:
		1280	offset = icmp_client_process_packet( packet, & type, & code, NULL, NULL );
		1281	if( offset < 0 ){
4711	mejdrech	1282	return ip_release_and_return( packet, ENOMEM );
4707	mejdrech	1283	}
		1284	data = packet_get_data( packet );
4720	mejdrech	1285	header = ( ip_header_ref )( data + offset );
4707	mejdrech	1286	// destination host unreachable?
		1287	if(( type == ICMP_DEST_UNREACH ) && ( code == ICMP_HOST_UNREACH )){
		1288	fibril_rwlock_read_lock( & ip_globals.netifs_lock );
		1289	netif = ip_netifs_find( & ip_globals.netifs, device_id );
		1290	if( netif && netif->arp ){
		1291	route = ip_routes_get_index( & netif->routes, 0 );
		1292	// from the same network?
		1293	if( route && (( route->address.s_addr & route->netmask.s_addr ) == ( header->destination_address & route->netmask.s_addr ))){
		1294	// clear the ARP mapping if any
		1295	address.value = ( char * ) & header->destination_address;
		1296	address.length = CONVERT_SIZE( uint8_t, char, sizeof( header->destination_address ));
		1297	arp_clear_address_req( netif->arp->phone, netif->device_id, SERVICE_IP, & address );
		1298	}
		1299	}
		1300	fibril_rwlock_read_unlock( & ip_globals.netifs_lock );
		1301	}
		1302	break;
		1303	default:
4711	mejdrech	1304	return ip_release_and_return( packet, ENOTSUP );
4707	mejdrech	1305	}
		1306	return ip_deliver_local( device_id, packet, header, error );
		1307	}
		1308
		1309	int ip_deliver_local( device_id_t device_id, packet_t packet, ip_header_ref header, services_t error ){
4505	mejdrech	1310	ERROR_DECLARE;
		1311
		1312	ip_proto_ref proto;
4707	mejdrech	1313	int phone;
4720	mejdrech	1314	services_t service;
		1315	tl_received_msg_t received_msg;
		1316	struct sockaddr * src;
		1317	struct sockaddr * dest;
		1318	struct sockaddr_in src_in;
		1319	struct sockaddr_in dest_in;
		1320	// struct sockaddr_in src_in6;
		1321	// struct sockaddr_in dest_in6;
		1322	socklen_t addrlen;
4505	mejdrech	1323
4731	mejdrech	1324	if(( header->flags & IPFLAG_MORE_FRAGMENTS ) \|\| IP_FRAGMENT_OFFSET( header )){
4505	mejdrech	1325	// TODO fragmented
		1326	return ENOTSUP;
		1327	}else{
4720	mejdrech	1328	switch( header->version ){
		1329	case IPVERSION:
		1330	addrlen = sizeof( src_in );
		1331	bzero( & src_in, addrlen );
		1332	src_in.sin_family = AF_INET;
		1333	memcpy( & dest_in, & src_in, addrlen );
		1334	memcpy( & src_in.sin_addr.s_addr, & header->source_address, sizeof( header->source_address ));
		1335	memcpy( & dest_in.sin_addr.s_addr, & header->destination_address, sizeof( header->destination_address ));
		1336	src = ( struct sockaddr * ) & src_in;
		1337	dest = ( struct sockaddr * ) & dest_in;
		1338	break;
		1339	/* case IPv6VERSION:
		1340	addrlen = sizeof( src_in6 );
		1341	bzero( & src_in6, addrlen );
		1342	src_in6.sin6_family = AF_INET6;
		1343	memcpy( & dest_in6, & src_in6, addrlen );
		1344	memcpy( & src_in6.sin6_addr.s6_addr, );
		1345	memcpy( & dest_in6.sin6_addr.s6_addr, );
		1346	src = ( struct sockaddr * ) & src_in;
		1347	dest = ( struct sockaddr * ) & dest_in;
		1348	break;
		1349	*/ default:
4735	mejdrech	1350	return ip_release_and_return( packet, EAFNOSUPPORT );
4720	mejdrech	1351	}
4735	mejdrech	1352	if( ERROR_OCCURRED( packet_set_addr( packet, ( uint8_t * ) src, ( uint8_t * ) dest, addrlen ))){
		1353	return ip_release_and_return( packet, ERROR_CODE );
		1354	}
		1355	// trim padding if present
		1356	if(( ! error ) && ( IP_TOTAL_LENGTH( header ) < packet_get_data_length( packet ))){
		1357	if( ERROR_OCCURRED( packet_trim( packet, 0, packet_get_data_length( packet ) - IP_TOTAL_LENGTH( header )))){
		1358	return ip_release_and_return( packet, ERROR_CODE );
		1359	}
		1360	}
4582	mejdrech	1361	fibril_rwlock_read_lock( & ip_globals.protos_lock );
4505	mejdrech	1362	proto = ip_protos_find( & ip_globals.protos, header->protocol );
4558	mejdrech	1363	if( ! proto ){
4582	mejdrech	1364	fibril_rwlock_read_unlock( & ip_globals.protos_lock );
4707	mejdrech	1365	phone = ip_prepare_icmp_and_get_phone( error, packet, header );
		1366	if( phone >= 0 ){
		1367	// unreachable ICMP
		1368	icmp_destination_unreachable_msg( phone, ICMP_PROT_UNREACH, 0, packet );
		1369	}
4558	mejdrech	1370	return ENOENT;
		1371	}
		1372	if( proto->received_msg ){
4720	mejdrech	1373	service = proto->service;
		1374	received_msg = proto->received_msg;
		1375	fibril_rwlock_read_unlock( & ip_globals.protos_lock );
		1376	ERROR_CODE = received_msg( device_id, packet, service, error );
4505	mejdrech	1377	}else{
4707	mejdrech	1378	ERROR_CODE = tl_received_msg( proto->phone, device_id, packet, proto->service, error );
4720	mejdrech	1379	fibril_rwlock_read_unlock( & ip_globals.protos_lock );
4505	mejdrech	1380	}
4558	mejdrech	1381	return ERROR_CODE;
4505	mejdrech	1382	}
		1383	}
		1384
		1385	in_addr_t ip_get_destination( ip_header_ref header ){
		1386	in_addr_t destination;
		1387
		1388	// TODO search set ipopt route?
4707	mejdrech	1389	destination.s_addr = header->destination_address;
4505	mejdrech	1390	return destination;
		1391	}
		1392
4707	mejdrech	1393	int ip_prepare_icmp( packet_t packet, ip_header_ref header ){
		1394	packet_t next;
4720	mejdrech	1395	struct sockaddr * dest;
		1396	struct sockaddr_in dest_in;
		1397	// struct sockaddr_in dest_in6;
		1398	socklen_t addrlen;
4707	mejdrech	1399
		1400	// detach the first packet and release the others
		1401	next = pq_detach( packet );
		1402	if( next ){
		1403	pq_release( ip_globals.net_phone, packet_get_id( next ));
		1404	}
		1405	if( ! header ){
		1406	if( packet_get_data_length( packet ) <= sizeof( ip_header_t )) return ENOMEM;
		1407	// get header
		1408	header = ( ip_header_ref ) packet_get_data( packet );
		1409	if( ! header ) return EINVAL;
		1410	}
		1411	// only for the first fragment
4731	mejdrech	1412	if( IP_FRAGMENT_OFFSET( header )) return EINVAL;
4707	mejdrech	1413	// set the destination address
4720	mejdrech	1414	switch( header->version ){
		1415	case IPVERSION:
		1416	addrlen = sizeof( dest_in );
		1417	bzero( & dest_in, addrlen );
		1418	dest_in.sin_family = AF_INET;
		1419	memcpy( & dest_in.sin_addr.s_addr, & header->source_address, sizeof( header->source_address ));
		1420	dest = ( struct sockaddr * ) & dest_in;
		1421	break;
		1422	/* case IPv6VERSION:
		1423	addrlen = sizeof( dest_in6 );
		1424	bzero( & dest_in6, addrlen );
		1425	dest_in6.sin6_family = AF_INET6;
		1426	memcpy( & dest_in6.sin6_addr.s6_addr, );
		1427	dest = ( struct sockaddr * ) & dest_in;
		1428	break;
		1429	*/ default:
		1430	return EAFNOSUPPORT;
		1431	}
		1432	return packet_set_addr( packet, NULL, ( uint8_t * ) dest, addrlen );
4707	mejdrech	1433	}
		1434
		1435	int ip_get_icmp_phone( void ){
		1436	ip_proto_ref proto;
		1437	int phone;
		1438
		1439	fibril_rwlock_read_lock( & ip_globals.protos_lock );
		1440	proto = ip_protos_find( & ip_globals.protos, IPPROTO_ICMP );
		1441	phone = proto ? proto->phone : ENOENT;
		1442	fibril_rwlock_read_unlock( & ip_globals.protos_lock );
		1443	return phone;
		1444	}
		1445
		1446	int ip_prepare_icmp_and_get_phone( services_t error, packet_t packet, ip_header_ref header ){
		1447	int phone;
		1448
		1449	phone = ip_get_icmp_phone();
		1450	if( error \|\| ( phone < 0 ) \|\| ip_prepare_icmp( packet, header )){
4711	mejdrech	1451	return ip_release_and_return( packet, EINVAL );
4707	mejdrech	1452	}
		1453	return phone;
		1454	}
		1455
4711	mejdrech	1456	int ip_release_and_return( packet_t packet, int result ){
4707	mejdrech	1457	pq_release( ip_globals.net_phone, packet_get_id( packet ));
		1458	return result;
		1459	}
		1460
4722	mejdrech	1461	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 ){
		1462	struct sockaddr_in * address_in;
		1463	// struct sockaddr_in6 * address_in6;
		1464	in_addr_t * dest;
		1465	in_addr_t * src;
		1466	ip_route_ref route;
		1467	ipv4_pseudo_header_ref header_in;
		1468
		1469	if( !( destination && ( addrlen > 0 ))) return EINVAL;
		1470	if( !( device_id && header && headerlen )) return EBADMEM;
4743	mejdrech	1471	if(( size_t ) addrlen < sizeof( struct sockaddr )){
4722	mejdrech	1472	return EINVAL;
		1473	}
		1474	switch( destination->sa_family ){
		1475	case AF_INET:
		1476	if( addrlen != sizeof( struct sockaddr_in )){
		1477	return EINVAL;
		1478	}
		1479	address_in = ( struct sockaddr_in * ) destination;
		1480	dest = & address_in->sin_addr;
		1481	break;
		1482	// TODO IPv6
		1483	/* case AF_INET6:
		1484	if( addrlen != sizeof( struct sockaddr_in6 )) return EINVAL;
		1485	address_in6 = ( struct sockaddr_in6 * ) dest;
		1486	address_in6.sin6_addr.s6_addr;
		1487	*/ default:
		1488	return EAFNOSUPPORT;
		1489	}
		1490	fibril_rwlock_read_lock( & ip_globals.lock );
		1491	route = ip_find_route( * dest );
		1492	if( !( route && route->netif )){
		1493	fibril_rwlock_read_unlock( & ip_globals.lock );
		1494	return ENOENT;
		1495	}
		1496	* device_id = route->netif->device_id;
		1497	src = ip_netif_address( route->netif );
		1498	fibril_rwlock_read_unlock( & ip_globals.lock );
		1499	* headerlen = sizeof( * header_in );
		1500	header_in = ( ipv4_pseudo_header_ref ) malloc( * headerlen );
		1501	if( ! header_in ) return ENOMEM;
		1502	bzero( header_in, * headerlen );
		1503	header_in->destination_address = dest->s_addr;
		1504	header_in->source_address = src->s_addr;
		1505	header_in->protocol = protocol;
		1506	header_in->data_length = 0;
		1507	* header = ( ip_pseudo_header_ref ) header_in;
		1508	return EOK;
		1509	}
		1510
3466	mejdrech	1511	/** @}
		1512	*/

Subversion Repositories HelenOS

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