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