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

 int ip_device_state_msg( int il_phone, device_id_t device_id, device_state_t state );
 int ip_register( int protocol, services_t service, int phone, tl_received_msg_t tl_received_msg );
 int ip_netif_initialize( ip_netif_ref ip_netif );
 int ip_send_route( packet_t packet, ip_netif_ref netif, ip_route_ref route, in_addr_t * src, in_addr_t dest );
-int ip_prepare_packet( in_addr_t * source, packet_t packet, measured_string_ref destination );
+int ip_prepare_packet( in_addr_t * source, in_addr_t dest, packet_t packet, measured_string_ref destination );
 packet_t    ip_split_packet( packet_t packet, size_t prefix, size_t content, size_t suffix, size_t addr_len );
 int ip_fragment_packet( packet_t packet, size_t length, size_t prefix, size_t suffix, size_t addr_len );
 int ip_fragment_packet_data( packet_t packet, packet_t new_packet, ip_header_ref header, ip_header_ref new_header, size_t length, void * src, void * dest, size_t address_length );
 ip_header_ref   ip_create_middle_header( packet_t packet, ip_header_ref last );
     ERROR_DECLARE;
     int                 length;
     ip_netif_ref        netif;
     ip_route_ref        route;
-    in_addr_t           dest;
+    in_addr_t *         dest;
     in_addr_t *         src;
     // addresses in the host byte order
     // should be the next hop address or the target destination address
-    length = packet_get_addr( packet, NULL, ( void * )( & dest.s_addr ));
+    length = packet_get_addr( packet, NULL, ( uint8_t ** ) & dest );
     if( length < 0 ){
         pq_release( ip_globals.net_phone, packet_get_id( packet ));
         return length;
+    }
     // TODO IPv6
         return EINVAL;
+    }
     rwlock_read_lock( & ip_globals.netifs_lock );
     // device specified?
 //  dest.s_addr = ntohl( dest.s_addr );
-    if( device_id ){
+    if( device_id > 0 ){
         netif = ip_netifs_find( & ip_globals.netifs, device_id );
-        route = ip_netif_find_route( netif, dest );
+        route = ip_netif_find_route( netif, * dest );
     }else{
         // TODO IPv6
-        route = ip_find_route( dest );
+        route = ip_find_route( * dest );
         netif = route ? route->netif : NULL;
+    }
     if( !( netif && route )){
         rwlock_read_unlock( & ip_globals.netifs_lock );
         pq_release( ip_globals.net_phone, packet_get_id( packet ));
         return ENOENT;
+    }
     // to me?
-    if( route->address.s_addr == dest.s_addr ){
+    if( route->address.s_addr == dest->s_addr ){
         // TODO loopback deliver
         rwlock_read_unlock( & ip_globals.netifs_lock );
         return ip_deliver_local( -1, packet, ( ip_header_ref ) packet_get_data( packet ));
+    }
     if( ! src ){
         rwlock_read_unlock( & ip_globals.netifs_lock );
         pq_release( ip_globals.net_phone, packet_get_id( packet ));
         return ENOENT;
+    }
-    if( ERROR_OCCURRED( ip_send_route( packet, netif, route, src, dest ))){
+    if( ERROR_OCCURRED( ip_send_route( packet, netif, route, src, * dest ))){
         pq_release( ip_globals.net_phone, packet_get_id( packet ));
+    }
     rwlock_read_unlock( & ip_globals.netifs_lock );
     return ERROR_CODE;
+}
     packet_t            tmp;
     measured_string_t   destination;
     measured_string_ref translation;
     char *              data;
-    if( route->gateway.s_addr ){
-        dest.s_addr = route->gateway.s_addr;
-    }
     // get destination hardware address
     if( netif->arp ){
-        destination.value = ( char * ) & dest.s_addr;
+        destination.value = route->gateway.s_addr ? ( char * ) & route->gateway.s_addr : ( char * ) & dest.s_addr;
         destination.length = CONVERT_SIZE( dest.s_addr, char, 1 );
         if( ERROR_OCCURRED( arp_translate_req( netif->arp->phone, netif->device_id, SERVICE_IP, & destination, & translation, & data ))){
             usleep( 200000 );
             ERROR_PROPAGATE( arp_translate_req( netif->arp->phone, netif->device_id, SERVICE_IP, & destination, & translation, & data ));
+        }
+        }
     }else translation = NULL;
     // process packet queue
     next = packet;
     do{
-        if( ERROR_OCCURRED( ip_prepare_packet( src, next, translation ))){
+        if( ERROR_OCCURRED( ip_prepare_packet( src, dest, next, translation ))){
             // release invalid packet
             tmp = pq_detach( next );
             if( next == packet ) packet = tmp;
             pq_release( ip_globals.net_phone, packet_get_id( next ));
             next = tmp;
+        }
+    }
     return EOK;
+}
-int ip_prepare_packet( in_addr_t * source, packet_t packet, measured_string_ref destination ){
+int ip_prepare_packet( in_addr_t * source, in_addr_t dest, packet_t packet, measured_string_ref destination ){
     ERROR_DECLARE;
     size_t              length;
     ip_header_ref       header;
         ERROR_PROPAGATE( packet_set_addr( packet, NULL, ( uint8_t * ) destination->value, CONVERT_SIZE( char, uint8_t, destination->length )));
+    }
     header->version = 4;
     header->total_length = htons( length );
     header->fragment_offset = 0;
-    if( source ) header->source_address = source->s_addr;//htonl( source.s_addr );
+    if( source ) header->source_address = source->s_addr;
+    header->destination_address = dest.s_addr;
     rwlock_write_lock( & ip_globals.lock );
     ++ ip_globals.packet_counter;
     header->identification = htons( ip_globals.packet_counter );
     rwlock_write_unlock( & ip_globals.lock );
     header->header_checksum = 0;
     return ENOTSUP;
+}
 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 ){
     ip_netif_ref    netif;
+    int             index;
     if( !( addr_len && prefix && content && suffix )) return EBADMEM;
+    * content = IP_MAX_CONTENT - IP_PREFIX;
     rwlock_read_lock( & ip_globals.netifs_lock );
+    if( device_id < 0 ){
+        * addr_len = IP_ADDR;
+        * prefix = 0;
+        * suffix = 0;
+        for( index = ip_netifs_count( & ip_globals.netifs ) - 1; index >= 0; -- index ){
+            netif = ip_netifs_get_index( & ip_globals.netifs, index );
+            if( netif ){
+                if( netif->addr_len > * addr_len ) * addr_len = netif->addr_len;
+                if( netif->prefix > * prefix ) * prefix = netif->prefix;
+                if( netif->suffix > * suffix ) * suffix = netif->suffix;
+            }
+        }
+        * prefix = * prefix + IP_PREFIX;
+        * suffix = * suffix + IP_SUFFIX;
+    }else{
-    netif = ip_netifs_find( & ip_globals.netifs, device_id );
+        netif = ip_netifs_find( & ip_globals.netifs, device_id );
-    if( ! netif ){
+        if( ! netif ){
-        rwlock_read_unlock( & ip_globals.netifs_lock );
+            rwlock_read_unlock( & ip_globals.netifs_lock );
-        return ENOENT;
+            return ENOENT;
+        }
+        * addr_len = ( netif->addr_len > IP_ADDR ) ? netif->addr_len : IP_ADDR;
+        * prefix = netif->prefix + IP_PREFIX;
+        * suffix = netif->suffix + IP_SUFFIX;
+    }
-    * content = IP_MAX_CONTENT - IP_PREFIX;
-    * addr_len = ( netif->addr_len > IP_ADDR ) ? netif->addr_len : IP_ADDR;
-    * prefix = netif->prefix + IP_PREFIX;
-    * suffix = netif->suffix + IP_SUFFIX;
     rwlock_read_unlock( & ip_globals.netifs_lock );
     return EOK;
+}
 int ip_add_route_req( int ip_phone, device_id_t device_id, in_addr_t address, in_addr_t netmask, in_addr_t gateway ){

Subversion Repositories HelenOS

(root)/branches/network/uspace/srv/net/il/ip/ip.c – Rev 4558 → 4575