WebSVN – HelenOS – Diff – /branches/network/uspace/srv/net/socket/socket_core.c

 /*
  * Copyright (c) 2009 Lukas Mejdrech
  * All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
+ *
  * - Redistributions of source code must retain the above copyright
  *   notice, this list of conditions and the following disclaimer.
  * - Redistributions in binary form must reproduce the above copyright
  *   notice, this list of conditions and the following disclaimer in the
  *   documentation and/or other materials provided with the distribution.
  * - The name of the author may not be used to endorse or promote products
  *   derived from this software without specific prior written permission.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 /** @addtogroup socket
  *  @{
  */
 /** @file
  *  \todo
  */
 #include "../err.h"
 #include "../include/in.h"
 #include "../include/inet.h"
 #include "../include/socket_codes.h"
 #include "../include/socket_errno.h"
 #include "../structures/dynamic_fifo.h"
 #include "../structures/int_map.h"
 #include "../structures/packet/packet.h"
 #include "../structures/packet/packet_client.h"
+#include "../modules.h"
 #include "socket_core.h"
+/** \todo
+ */
+struct socket_port{
+    socket_port_map_t   map;
+    int                 count;
+};
+/** \todo
+ */
 int socket_bind_insert( socket_ports_ref global_sockets, socket_core_ref socket, int port );
+/** \todo
+ */
+void    socket_destroy_core( int packet_phone, socket_core_ref socket, socket_cores_ref local_sockets, socket_ports_ref global_sockets, void ( * socket_release )( socket_core_ref socket ));
+/** \todo
+ */
+int socket_port_add_core( socket_port_ref socket_port, socket_core_ref socket, const char * key, size_t key_length );
 INT_MAP_IMPLEMENT( socket_cores, socket_core_t );
+GENERIC_CHAR_MAP_IMPLEMENT( socket_port_map, socket_core_ref );
-INT_MAP_IMPLEMENT( socket_ports, socket_core_ref );
+INT_MAP_IMPLEMENT( socket_ports, socket_port_t );
+void socket_cores_release( int packet_phone, socket_cores_ref local_sockets, socket_ports_ref global_sockets, void ( * socket_release )( socket_core_ref socket )){
+    if( socket_cores_is_valid( local_sockets )){
+        int index;
+        local_sockets->magic = 0;
+        for( index = 0; index < local_sockets->next; ++ index ){
+            if( socket_cores_item_is_valid( &( local_sockets->items[ index ] ))){
+                local_sockets->items[ index ].magic = 0;
+                if( local_sockets->items[ index ].value ){
+                    socket_destroy_core( packet_phone, local_sockets->items[ index ].value, local_sockets, global_sockets, socket_release );
+                    free( local_sockets->items[ index ].value );
+                    local_sockets->items[ index ].value = NULL;
+                }
+            }
+        }
+        free( local_sockets->items );
+    }
+}
+void socket_destroy_core( int packet_phone, socket_core_ref socket, socket_cores_ref local_sockets, socket_ports_ref global_sockets, void ( * socket_release )( socket_core_ref socket )){
+    int packet_id;
+    // if bound
+    if( socket->port ){
+        // release the port
+        socket_port_release( global_sockets, socket );
+    }
+    // release all received packets
+    while(( packet_id = dyn_fifo_pop( & socket->received )) >= 0 ){
+        pq_release( packet_phone, packet_id );
+    }
+    dyn_fifo_destroy( & socket->received );
+    dyn_fifo_destroy( & socket->accepted );
+    if( socket_release ){
+        socket_release( socket );
+    }
+    socket_cores_exclude( local_sockets, socket->socket_id );
+}
 int socket_bind( socket_cores_ref local_sockets, socket_ports_ref global_sockets, int socket_id, void * addr, size_t addrlen, int free_ports_start, int free_ports_end, int last_used_port ){
     socket_core_ref         socket;
-    socket_core_ref *       socket_pointer;
+    socket_port_ref         socket_port;
     struct sockaddr *       address;
     struct sockaddr_in *    address_in;
     if( addrlen < sizeof( struct sockaddr )) return EINVAL;
     address = ( struct sockaddr * ) addr;
     switch( address->sa_family ){
         case AF_INET:
             if( addrlen != sizeof( struct sockaddr_in )) return EINVAL;
             address_in = ( struct sockaddr_in * ) addr;
             // find the socket
             socket = socket_cores_find( local_sockets, socket_id );
             if( ! socket ) return ENOTSOCK;
             // bind a free port?
             if( address_in->sin_port <= 0 ){
                 return socket_bind_free_port( global_sockets, socket, free_ports_start, free_ports_end, last_used_port );
+            }
             // try to find the port
-            socket_pointer = socket_ports_find( global_sockets, address_in->sin_port );
+            socket_port = socket_ports_find( global_sockets, ntohs( address_in->sin_port ));
-            if( socket_pointer ){
+            if( socket_port ){
                 // already used
                 return EADDRINUSE;
+            }
-            // unbind if bound
+            // if bound
+            if( socket->port ){
+                // release the port
-            socket_ports_exclude( global_sockets, socket->port );
+                socket_port_release( global_sockets, socket );
+            }
             socket->port = -1;
-            return socket_bind_insert( global_sockets, socket, address_in->sin_port );
+            return socket_bind_insert( global_sockets, socket, ntohs( address_in->sin_port ));
             break;
         // TODO IPv6
+    }
     return EAFNOSUPPORT;
+}
 int socket_bind_free_port( socket_ports_ref global_sockets, socket_core_ref socket, int free_ports_start, int free_ports_end, int last_used_port ){
     int index;
     // from the last used one
     index = last_used_port;
     do{
         ++ index;
         // til the range end
         if( index >= free_ports_end ){
             // start from the range beginning
             index = free_ports_start - 1;
             do{
                 ++ index;
                 // til the last used one
                 if( index >= last_used_port ){
                     // none found
                     return ENOTCONN;
+                }
             }while( socket_ports_find( global_sockets, index ) != NULL );
             // found, break immediately
             break;
+        }
     }while( socket_ports_find( global_sockets, index ) != NULL );
     return socket_bind_insert( global_sockets, socket, index );
+}
 int socket_bind_insert( socket_ports_ref global_sockets, socket_core_ref socket, int port ){
     ERROR_DECLARE;
-    socket_core_ref *   socket_pointer;
+    socket_port_ref socket_port;
     // create a wrapper
-    socket_pointer = ( socket_core_ref * ) malloc( sizeof( socket_core_ref ));
+    socket_port = malloc( sizeof( * socket_port ));
-    if( ! socket_pointer ) return ENOMEM;
+    if( ! socket_port ) return ENOMEM;
-    * socket_pointer = socket;
+    socket_port->count = 0;
+    if( ERROR_OCCURRED( socket_port_map_initialize( & socket_port->map ))
+    || ERROR_OCCURRED( socket_port_add_core( socket_port, socket, SOCKET_MAP_KEY_LISTENING, 0 ))){
+        socket_port_map_destroy( & socket_port->map );
+        free( socket_port );
+        return ERROR_CODE;
+    }
     // register the incomming port
-    ERROR_CODE = socket_ports_add( global_sockets, port, socket_pointer );
+    ERROR_CODE = socket_ports_add( global_sockets, port, socket_port );
     if( ERROR_CODE < 0 ){
+        socket_port_map_destroy( & socket_port->map );
-        free( socket_pointer );
+        free( socket_port );
         return ERROR_CODE;
+    }
     socket->port = port;
     return EOK;
+}
 int socket_create( socket_cores_ref local_sockets, int app_phone, void * specific_data, int * socket_id ){
     ERROR_DECLARE;
     socket_core_ref socket;
     int             res;
     if( ! socket_id ) return EBADMEM;
     socket = ( socket_core_ref ) malloc( sizeof( * socket ));
     if( ! socket ) return ENOMEM;
     // initialize
     socket->phone = app_phone;
     socket->port = -1;
+    socket->key = NULL;
+    socket->key_length = 0;
     socket->specific_data = specific_data;
     if( ERROR_OCCURRED( dyn_fifo_initialize( & socket->received, SOCKET_INITIAL_RECEIVED_SIZE ))){
         free( socket );
         return ERROR_CODE;
+    }
     if( ERROR_OCCURRED( dyn_fifo_initialize( & socket->accepted, SOCKET_INITIAL_ACCEPTED_SIZE ))){
         dyn_fifo_destroy( & socket->received );
         free( socket );
         return ERROR_CODE;
+    }
     // get a next free socket number
     socket->socket_id = socket_cores_count( local_sockets ) + 1;
     // store the socket
     res = socket_cores_add( local_sockets, socket->socket_id, socket );
     if( res < 0 ){
         dyn_fifo_destroy( & socket->received );
         dyn_fifo_destroy( & socket->accepted );
         free( socket );
         return res;
+    }
     // return the socket identifier
     * socket_id = socket->socket_id;
     return EOK;
+}
-int socket_destroy( int packet_phone, int socket_id, socket_cores_ref local_sockets, socket_ports_ref global_sockets ){
+int socket_destroy( int packet_phone, int socket_id, socket_cores_ref local_sockets, socket_ports_ref global_sockets, void ( * socket_release )( socket_core_ref socket )){
     socket_core_ref socket;
     int             accepted_id;
-    int             packet_id;
     // find the socket
     socket = socket_cores_find( local_sockets, socket_id );
     if( ! socket ) return ENOTSOCK;
-    socket_ports_exclude( global_sockets, socket->port );
     // destroy all accepted sockets
     while(( accepted_id = dyn_fifo_pop( & socket->accepted )) >= 0 ){
-        socket_destroy( packet_phone, accepted_id, local_sockets, global_sockets );
+        socket_destroy( packet_phone, accepted_id, local_sockets, global_sockets, socket_release );
+    }
+    socket_destroy_core( packet_phone, socket, local_sockets, global_sockets, socket_release );
-    // release all received packets
+    return EOK;
+}
-    while(( packet_id = dyn_fifo_pop( & socket->received )) >= 0 ){
+int socket_reply_packets( packet_t packet, size_t * length ){
+    ERROR_DECLARE;
-        pq_release( packet_phone, packet_id );
+    packet_t        next_packet;
+    size_t          fragments;
+    size_t *        lengths;
+    size_t          index;
+    if( ! length ){
+        return EINVAL;
+    }
+    next_packet = pq_next( packet );
+    if( ! next_packet ){
+        // write all if only one fragment
+        ERROR_PROPAGATE( data_reply( packet_get_data( packet ), packet_get_data_length( packet )));
+        // store the total length
+        * length = packet_get_data_length( packet );
+    }else{
+        // count the packet fragments
+        fragments = 1;
+        next_packet = pq_next( packet );
+        while(( next_packet = pq_next( next_packet ))){
+            ++ fragments;
+        }
+        // compute and store the fragment lengths
+        lengths = ( size_t * ) malloc( sizeof( size_t ) * fragments + sizeof( size_t ));
+        if( ! lengths ) return ENOMEM;
+        lengths[ 0 ] = packet_get_data_length( packet );
+        lengths[ fragments ] = lengths[ 0 ];
+        next_packet = pq_next( packet );
+        for( index = 1; index < fragments; ++ index ){
+            lengths[ index ] = packet_get_data_length( next_packet );
+            lengths[ fragments ] += lengths[ index ];
+            next_packet = pq_next( packet );
+        }while( next_packet );
+        // write the fragment lengths
+        ERROR_PROPAGATE( data_reply( lengths, sizeof( int ) * ( fragments + 1 )));
+        next_packet = packet;
+        // write the fragments
+        for( index = 0; index < fragments; ++ index ){
+            ERROR_PROPAGATE( data_reply( packet_get_data( next_packet ), lengths[ index ] ));
+            next_packet = pq_next( next_packet );
+        }while( next_packet );
+        // store the total length
+        * length = lengths[ fragments ];
+        free( lengths );
+    }
+    return EOK;
+}
+socket_core_ref socket_port_find( socket_ports_ref global_sockets, int port, const char * key, size_t key_length ){
+    socket_port_ref     socket_port;
+    socket_core_ref *   socket_ref;
+    socket_port = socket_ports_find( global_sockets, port );
-    dyn_fifo_destroy( & socket->received );
+    if( socket_port && ( socket_port->count > 0 )){
+        socket_ref = socket_port_map_find( & socket_port->map, key, key_length );
+        if( socket_ref ){
+            return * socket_ref;
+        }
+    }
+    return NULL;
+}
+void socket_port_release( socket_ports_ref global_sockets, socket_core_ref socket ){
+    socket_port_ref socket_port;
+    socket_core_ref *   socket_ref;
+    if( socket->port ){
+        // find ports
+        socket_port = socket_ports_find( global_sockets, socket->port );
+        if( socket_port ){
+            // find the socket
+            socket_ref = socket_port_map_find( & socket_port->map, socket->key, socket->key_length );
+            if( socket_ref ){
+                -- socket_port->count;
+                // release if empty
+                if( socket_port->count <= 0 ){
+                    // destroy the map
-    dyn_fifo_destroy( & socket->accepted );
+                    socket_port_map_destroy( & socket_port->map );
+                    // release the port
-    socket_cores_exclude( local_sockets, socket_id );
+                    socket_ports_exclude( global_sockets, socket->port );
+                }else{
+                    // remove
+                    socket_port_map_exclude( & socket_port->map, socket->key, socket->key_length );
+                }
+            }
+        }
+        socket->port = 0;
+        socket->key = NULL;
+        socket->key_length = 0;
+    }
+}
+int socket_port_add( socket_ports_ref global_sockets, int port, socket_core_ref socket, const char * key, size_t key_length ){
+    ERROR_DECLARE;
+    socket_port_ref     socket_port;
+    // find ports
+    socket_port = socket_ports_find( global_sockets, port );
+    if( ! socket_port ) return ENOENT;
+    // add the socket
+    ERROR_PROPAGATE( socket_port_add_core( socket_port, socket, key, key_length ));
+    socket->port = port;
+    return EOK;
+}
+int socket_port_add_core( socket_port_ref socket_port, socket_core_ref socket, const char * key, size_t key_length ){
+    ERROR_DECLARE;
+    socket_core_ref *   socket_ref;
+    // create a wrapper
+    socket_ref = malloc( sizeof( * socket_ref ));
+    if( ! socket_ref ) return ENOMEM;
+    * socket_ref = socket;
+    // add the wrapper
+    if( ERROR_OCCURRED( socket_port_map_add( & socket_port->map, key, key_length, socket_ref ))){
+        free( socket_ref );
+        return ERROR_CODE;
+    }
+    ++ socket_port->count;
+    socket->key = key;
+    socket->key_length = key_length;
     return EOK;
+}
 /** @}
  */

Subversion Repositories HelenOS

(root)/branches/network/uspace/srv/net/socket/socket_core.c @ 4756 – Rev 4730 → 4738