WebSVN – HelenOS – Diff – /branches/network/uspace/srv/net/tl/udp/udp.c

 /** @file
  */
 #include <async.h>
+#include <fibril_sync.h>
 #include <malloc.h>
 #include <stdio.h>
 #include <ipc/ipc.h>
 #include <ipc/services.h>
 #include "udp_header.h"
 #include "udp_module.h"
 #define MAX_UDP_FRAGMENT_SIZE   65535
+#define UDP_FREE_PORTS_START    1025
+#define UDP_FREE_PORTS_END      65535
 int udp_received_msg( device_id_t device_id, packet_t packet, services_t receiver );
 int udp_process_packet( packet_t packet );
 int process_client_messages( ipc_callid_t callid, ipc_call_t * call, ipc_call_t * answer, int * answer_count );
 int udp_sendto_message( socket_cores_ref local_sockets, int socket_id, void * addr, size_t addrlen, int fragments, int flags );
 int udp_recvfrom_message( socket_cores_ref local_sockets, int socket_id, int flags );
 /** Initializes the module.
  */
 int udp_initialize( async_client_conn_t client_connection ){
     ERROR_DECLARE;
+    fibril_rwlock_initialize( & udp_globals.lock );
+    fibril_rwlock_write_lock( & udp_globals.lock );
     udp_globals.ip_phone = ip_bind_service( SERVICE_IP, IPPROTO_UDP, SERVICE_UDP, client_connection, udp_received_msg );
     if( udp_globals.ip_phone < 0 ){
         return udp_globals.ip_phone;
+    }
     ERROR_PROPAGATE( ip_packet_size_req( udp_globals.ip_phone, -1, & udp_globals.addr_len, & udp_globals.prefix, & udp_globals.content, & udp_globals.suffix ));
     ERROR_PROPAGATE( socket_ports_initialize( & udp_globals.sockets ));
     udp_globals.prefix += sizeof( udp_header_t );
     udp_globals.content -= sizeof( udp_header_t );
+    udp_globals.last_used_port = UDP_FREE_PORTS_START - 1;
+    fibril_rwlock_write_unlock( & udp_globals.lock );
     return EOK;
+}
 int udp_received_msg( device_id_t device_id, packet_t packet, services_t receiver ){
     ERROR_DECLARE;
     packet_t    packet;
     * answer_count = 0;
     switch( IPC_GET_METHOD( * call )){
         case NET_TL_RECEIVED:
+            fibril_rwlock_read_lock( & udp_globals.lock );
-            ERROR_PROPAGATE( packet_translate( udp_globals.net_phone, & packet, IPC_GET_PACKET( call )));
+            if( ! ERROR_OCCURRED( packet_translate( udp_globals.net_phone, & packet, IPC_GET_PACKET( call )))){
-            return udp_received_msg( IPC_GET_DEVICE( call ), packet, 0 );
+                ERROR_CODE = udp_received_msg( IPC_GET_DEVICE( call ), packet, 0 );
+            }
+            fibril_rwlock_read_unlock( & udp_globals.lock );
+            return ERROR_CODE;
         case IPC_M_CONNECT_TO_ME:
             return process_client_messages( callid, call, answer, answer_count );
+    }
     return ENOTSUP;
+}
     bool                    keep_on_going = true;
     socket_cores_t          local_sockets;
     int                     app_phone = IPC_GET_PHONE( call );
     void *                  addr;
     size_t                  addrlen;
+    fibril_rwlock_t         lock;
     /*
      * Accept the connection
      *  - Answer the first IPC_M_CONNECT_ME_TO call.
      */
     ipc_answer_0( callid, EOK );
     socket_cores_initialize( & local_sockets );
+    fibril_rwlock_initialize( & lock );
     while( keep_on_going ){
         // refresh data
         * answer_count = 0;
         IPC_SET_RETVAL( * answer, 0 );
             case IPC_M_PHONE_HUNGUP:
                 keep_on_going = false;
                 res = EOK;
                 break;
             case NET_SOCKET:
+                fibril_rwlock_write_lock( & lock );
                 res = socket_create( & local_sockets, app_phone, SOCKET_SET_SOCKET_ID( answer ));
+                fibril_rwlock_write_unlock( & lock );
                 * SOCKET_SET_HEADER_SIZE( answer ) = sizeof( udp_header_t );
                 * SOCKET_SET_DATA_FRAGMENT_SIZE( answer ) = MAX_UDP_FRAGMENT_SIZE;
                 * answer_count = 3;
                 break;
             case NET_SOCKET_BIND:
                 if( ERROR_OCCURRED( socket_read_data( & addr, & addrlen ))){
                     res = ERROR_CODE;
                     break;
+                }
+                fibril_rwlock_write_lock( & lock );
+                fibril_rwlock_write_lock( & udp_globals.lock );
-                res = socket_bind( & local_sockets, & udp_globals.sockets, SOCKET_GET_SOCKET_ID( call ), addr, addrlen );
+                res = socket_bind( & local_sockets, & udp_globals.sockets, SOCKET_GET_SOCKET_ID( call ), addr, addrlen, UDP_FREE_PORTS_START, UDP_FREE_PORTS_END, udp_globals.last_used_port );
+                fibril_rwlock_write_unlock( & udp_globals.lock );
+                fibril_rwlock_write_unlock( & lock );
                 free( addr );
                 break;
             case NET_SOCKET_SENDTO:
                 if( ERROR_OCCURRED( socket_read_data( & addr, & addrlen ))){
                     res = ERROR_CODE;
                     break;
+                }
+                fibril_rwlock_read_lock( & lock );
+                fibril_rwlock_read_lock( & udp_globals.lock );
                 res = udp_sendto_message( & local_sockets, SOCKET_GET_SOCKET_ID( call ), addr, addrlen, SOCKET_GET_DATA_FRAGMENTS( call ), SOCKET_GET_FLAGS( call ));
+                fibril_rwlock_read_unlock( & udp_globals.lock );
+                fibril_rwlock_read_unlock( & lock );
                 free( addr );
                 break;
             case NET_SOCKET_RECVFROM:
+                fibril_rwlock_read_lock( & lock );
+                fibril_rwlock_read_lock( & udp_globals.lock );
                 res = udp_recvfrom_message( & local_sockets, SOCKET_GET_SOCKET_ID( call ), SOCKET_GET_FLAGS( call ));
+                fibril_rwlock_read_unlock( & udp_globals.lock );
+                fibril_rwlock_read_unlock( & lock );
                 if( res > 0 ){
                     * SOCKET_SET_READ_DATA_LENGTH( answer ) = res;
                     * SOCKET_SET_ADDRESS_LENGTH( answer ) = sizeof( struct sockaddr_in );
                     * answer_count = 2;
                     res = EOK;
+                }
                 break;
             case NET_SOCKET_CLOSE:
+                fibril_rwlock_write_lock( & lock );
+                fibril_rwlock_write_lock( & udp_globals.lock );
                 res = socket_destroy( udp_globals.net_phone, SOCKET_GET_SOCKET_ID( call ), & local_sockets, & udp_globals.sockets );
+                fibril_rwlock_write_unlock( & udp_globals.lock );
+                fibril_rwlock_write_unlock( & lock );
                 break;
             case NET_SOCKET_GETSOCKOPT:
             case NET_SOCKET_SETSOCKOPT:
             default:
                 res = ENOTSUP;
             if( addrlen != sizeof( struct sockaddr_in )) return EINVAL;
             address_in = ( struct sockaddr_in * ) addr;
             socket = socket_cores_find( local_sockets, socket_id );
             if( ! socket ) return ENOTSOCK;
+            // bind the socket to a random free port if not bound
+            if( socket->port <= 0 ){
+                // try to find a free port
+                fibril_rwlock_read_unlock( & udp_globals.lock );
+                fibril_rwlock_write_lock( & udp_globals.lock );
+                ERROR_PROPAGATE( socket_bind_free_port( & udp_globals.sockets, socket, UDP_FREE_PORTS_START, UDP_FREE_PORTS_END, udp_globals.last_used_port ));
+                fibril_rwlock_write_unlock( & udp_globals.lock );
+                fibril_rwlock_read_lock( & udp_globals.lock );
+                // set the next port as the search starting port number
+                udp_globals.last_used_port = socket->port;
+            }
             // TODO do not ask all the time
             ERROR_PROPAGATE( ip_packet_size_req( udp_globals.ip_phone, -1, & udp_globals.addr_len, & udp_globals.prefix, & udp_globals.content, & udp_globals.suffix ));
             // read the first packet fragment
             total_length = socket_read_packet_data( & packet, sizeof( udp_header_t ), address_in );

Subversion Repositories HelenOS

(root)/branches/network/uspace/srv/net/tl/udp/udp.c – Rev 4603 → 4700