Subversion Repositories HelenOS

Rev

Rev 4731 | Rev 4743 | Go to most recent revision | Only display areas with differences | Regard whitespace | Details | Blame | Last modification | View Log | RSS feed

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