Changeset 663 for trunk/kernel

Timestamp:

Oct 10, 2020, 4:56:11 PM (4 years ago)

Author:

alain

Message:

Introduce support for both TCP in the dev_nic.h & dev_nic.c files.

Location:

trunk/kernel/devices

Files:

• dev_ioc.c (modified) (1 diff)
• dev_mmc.h (modified) (3 diffs)
• dev_nic.c (modified) (50 diffs)
• dev_nic.h (modified) (13 diffs)
• dev_txt.c (modified) (1 diff)

trunk/kernel/devices/dev_ioc.c

@@ -78 +78 @@
                                   lid );
 
-    assert( (error == 0) , "cannot create server thread" );
+assert( (error == 0) , "cannot create server thread" );
 
     // set "server" field in chdev descriptor

trunk/kernel/devices/dev_mmc.h

@@ -96 +96 @@
 
 /*****************************************************************************************
- * This function initializes the driver specific fields in the generic MMC device 
- * descriptor, and the implementation specific driver.
+ * This function initializes the driver specific fields in the local MMC chdev,  
+ * and initializes the implementation specific MMC  driver.
  * It must be executed once in any cluster containing an L2 cache.
  *****************************************************************************************
@@ -105 +105 @@
 
 /*****************************************************************************************
- * This function invalidates all cache lines covering a memory buffer 
- * in the physical address space. 
+ * This function invalidates all cache lines covering a memory buffer  defined by 
+ * the <buf_xp> and <buf_size> arguments.
  * It can be executed by any thread in any cluster, because it uses remote accesses
  * to access both the MMC device descriptor, and the L2 cache configuration interface.
@@ -119 +119 @@
 /*****************************************************************************************
  * This function forces the L2 cache to synchronize the L3 cache for all cache lines
- * covering a memory buffer in the physical address space. 
+ * covering a memory buffer defined by the <buf_xp> and <buf_size> arguments.
  * It can be executed by any thread in any cluster, because it uses remote accesses
  * to access both the MMC device descriptor, and the L2 cache configuration interface.

trunk/kernel/devices/dev_nic.c

@@ +1 @@
+
 /*
  * dev_nic.c - NIC (Network Controler) generic device API implementation.
@@ -26 +27 @@
 #include <hal_uspace.h>
 #include <remote_buf.h>
+#include <memcpy.h>
 #include <printk.h>
 #include <chdev.h>
 #include <thread.h>
-#include <socket.h>
+#include <ksocket.h>
 #include <hal_drivers.h>
 #include <dev_nic.h>
@@ -41 +43 @@
 extern chdev_directory_t  chdev_dir;         // allocated in kernel_init.c
 
+////////////////////////////////////
+void dev_nic_init( chdev_t * chdev )
+{
+    thread_t * new_thread;
+    error_t    error;
+
+    // get "channel" & "is_rx" fields from chdev descriptor
+    uint32_t  channel = chdev->channel;
+    bool_t    is_rx   = chdev->is_rx;
+
+    // set chdev name
+    if( is_rx ) snprintf( chdev->name , 16 , "nic%d_rx" , channel );
+    else        snprintf( chdev->name , 16 , "nic%d_tx" , channel );
+
+    // initialize the root of the listening sockets list
+    xlist_root_init( XPTR( local_cxy , &chdev->ext.nic.root ) );
+
+    // initialize the lock protecting this list
+    remote_busylock_init( XPTR( local_cxy , &chdev->ext.nic.lock ),
+                          LOCK_LISTEN_SOCKET );
+
+    // call driver init function for this chdev
+    hal_drivers_nic_init( chdev );
+
+    // select a core to execute the NIC server thread
+    lid_t lid = cluster_select_local_core( local_cxy );
+
+    // bind the NIC IRQ to the selected core
+    dev_pic_bind_irq( lid , chdev );
+
+    // build pointer on server function
+    void * func = is_rx ? &dev_nic_rx_server : &dev_nic_tx_server;
+
+    // create server thread
+    error = thread_kernel_create( &new_thread,
+                                  THREAD_DEV,
+                                  func,
+                                  chdev,
+                                  lid ); 
+    if( error )
+    {
+        printk("\n[PANIC] in %s : cannot create server thread\n", __FUNCTION__ );
+        return;
+    }
+
+    // set "server" field in chdev descriptor
+    chdev->server = new_thread;
+    
+    // set "chdev" field in thread descriptor
+    new_thread->chdev = chdev;
+
+    // unblock server thread
+    thread_unblock( XPTR( local_cxy , new_thread ) , THREAD_BLOCKED_GLOBAL );
+
+#if (DEBUG_DEV_NIC_TX || DEBUG_DEV_NIC_RX)
+thread_t * this = CURRENT_THREAD;
+if( is_rx )
+printk("\n[%s] thread[%x,%x] initialized NIC_RX[%d] / server %x\n",
+__FUNCTION__, this->process->pid, this->trdid, channel, new_thread->trdid );
+else
+printk("\n[%s] thread[%x,%x] initialized NIC_TX[%d] / server %x\n",
+__FUNCTION__, this->process->pid, this->trdid, channel, new_thread->trdid );
+#endif
+   
+}  // end dev_nic_init()
+
+
+///////////////////////////////////////////////////////////////////////////////////////////
+//      Functions directly called by the client threads
+///////////////////////////////////////////////////////////////////////////////////////////
+
+////////////////////////////////////////
+uint32_t dev_nic_get_key( uint32_t addr,
+                          uint16_t port )
+{
+    thread_t * this = CURRENT_THREAD;
+    
+    xptr_t dev_xp = chdev_dir.nic_tx[0];
+    chdev_t * dev_ptr = GET_PTR( dev_xp );
+
+    if( dev_xp == XPTR_NULL ) return -1;
+    
+    // set command arguments in client thread descriptor
+    this->nic_cmd.buffer = (uint8_t *)addr;
+    this->nic_cmd.length = (uint32_t)port;
+    this->nic_cmd.dev_xp = dev_xp;
+    this->nic_cmd.type   = NIC_CMD_GET_KEY;
+
+    // call driver 
+    dev_ptr->cmd( XPTR( local_cxy , this ) );
+
+    // get "status" 
+    return this->nic_cmd.status;
+}
+
+//////////////////////////////////////////
+error_t dev_nic_set_run( uint32_t channel,
+                         uint32_t run )
+{
+    thread_t * this = CURRENT_THREAD;
+
+    if( channel >= LOCAL_CLUSTER->nb_nic_channels ) return -1;
+
+    xptr_t    dev_xp  = chdev_dir.nic_tx[0];
+    chdev_t * dev_ptr = GET_PTR( dev_xp );
+
+    if( dev_xp == XPTR_NULL ) return -1;
+    
+    // set command arguments in client thread descriptor
+    this->nic_cmd.dev_xp = dev_xp;
+    this->nic_cmd.type   = NIC_CMD_SET_RUN;
+    this->nic_cmd.length = channel;
+    this->nic_cmd.status = run;
+
+    // call driver 
+    dev_ptr->cmd( XPTR( local_cxy , this ) );
+
+    // return "error" 
+    return this->nic_cmd.error;
+}
+
+//////////////////////////////////
+error_t dev_nic_get_instru( void )
+{
+    thread_t * this = CURRENT_THREAD;
+
+    xptr_t    dev_xp  = chdev_dir.nic_tx[0];
+    chdev_t * dev_ptr = GET_PTR( dev_xp );
+    
+    if( dev_xp == XPTR_NULL ) return -1;
+    
+    // set command arguments in client thread descriptor
+    this->nic_cmd.dev_xp = dev_xp;
+    this->nic_cmd.type   = NIC_CMD_GET_INSTRU;
+
+    // call driver 
+    dev_ptr->cmd( XPTR( local_cxy , this ) );
+
+    // return "error" 
+    return this->nic_cmd.error;
+}
+
+////////////////////////////////////
+error_t dev_nic_clear_instru( void )
+{
+    thread_t * this = CURRENT_THREAD;
+
+    xptr_t    dev_xp  = chdev_dir.nic_tx[0];
+    chdev_t * dev_ptr = GET_PTR( dev_xp );
+    
+    if( dev_xp == XPTR_NULL ) return -1;
+    
+    // set command arguments in client thread descriptor
+    this->nic_cmd.dev_xp = dev_xp;
+    this->nic_cmd.type   = NIC_CMD_GET_INSTRU;
+
+    // call driver 
+    dev_ptr->cmd( XPTR( local_cxy , this ) );
+
+    // return "error" 
+    return this->nic_cmd.error;
+}
+
+
 ////////////////////////////////////////////////////////////////////////////////////////////
-// This static function is used by the dev_nic_rx_handle_tcp() & dev_nic_tx_handle_tcp()
-// functions to check acceptability of a given sequence number. It returns true when 
-// the <seq> argument is contained in a wrap-around window defined by the <min> and <max>
-// arguments. The window wrap-around when (min > max).
+//      Static functions called by the NIC_RX server & NIC_TX server threads
+////////////////////////////////////////////////////////////////////////////////////////////
+
+////////////////////////////////////////////////////////////////////////////////////////////
+// This static function is used by the dev_nic_rx_handle_tcp() function
+// to check acceptability of a given sequence number. It returns true when 
+// the <seq> argument is contained in a wrap-around window defined by the 
+// <min> and <max> arguments. The window wrap-around when (min > max).
 ////////////////////////////////////////////////////////////////////////////////////////////
 // @ seq   : [in] value to be checked.
@@ -65 +235 @@
 }  
 
-////////////////////////////////////////////////////////////////////////////////////////////
-// this static function compute a channel index in range [0,nic_channelx[ from
-// a remote IP address and remote port.
-// TODO this function should be provided by the NIC driver.
-////////////////////////////////////////////////////////////////////////////////////////////
-// @ addr     : [in] IP address.
-// @ port     : [in] TCP/UDP port.
-////////////////////////////////////////////////////////////////////////////////////////////
-static inline uint32_t dev_nic_channel_index( uint32_t addr,
-                                              uint16_t port )
-{
-    // get number of NIC channels
-    uint32_t nic_channels = LOCAL_CLUSTER->nb_nic_channels;
- 
-    // compute NIC channel index
-    return ( ((addr     ) & 0xFF) ^
-             ((addr > 8 ) & 0xFF) ^
-             ((addr > 16) & 0xFF) ^
-             ((addr > 24) & 0xFF) ^
-             ((port     ) & 0xFF) ^
-             ((port > 8 ) & 0xFF) ) % nic_channels;
-}
-
 ////////////////////////////////////////////////////////////////////////////////////////
 // This static function computes the checksum for an IP packet header.
@@ -95 +242 @@
 // @ return the checksum value on 16 bits
 ////////////////////////////////////////////////////////////////////////////////////////
-uint16_t dev_nic_ip_checksum( uint8_t  * buffer )
+static uint16_t dev_nic_ip_checksum( uint8_t  * buffer )
 {
     uint32_t   i;           
@@ -121 +268 @@
 // @ return the checksum value on 16 bits
 ////////////////////////////////////////////////////////////////////////////////////////
-uint16_t dev_nic_udp_checksum( uint8_t  * buffer,
-                               uint32_t   size )
+static uint16_t dev_nic_udp_checksum( uint8_t  * buffer,
+                                      uint32_t   size )
 {
     uint32_t   i;           
@@ -158 +305 @@
 
 ////////////////////////////////////////////////////////////////////////////////////////
-// This static function computes the checksum for a TCP segment defined by
-// the <buffer> and <size> arguments.
-// It includes the pseudo header defined by the <src_ip_addr>, <dst_ip_addr>,
-// <size> arguments, and by the TCP_PROTOCOL code.
+// This static function computes the checksum for a TCP segment defined by the <buffer> 
+// and <size> arguments. It includes the pseudo header defined by the <src_ip_addr>,
+// <dst_ip_addr>, <size> arguments, and by the TCP_PROTOCOL code.
 ////////////////////////////////////////////////////////////////////////////////////////
 // @ buffer      : [in] pointer on TCP segment base.
-// @ size        : [in] number of bytes in this segment (including header).
+// @ tcp_length  : [in] number of bytes in this TCP segment (including header).
 // @ src_ip_addr : [in] source IP address (pseudo header)
 // @ dst_ip_addr : [in] destination IP address (pseudo header)
 // @ return the checksum value on 16 bits
 ////////////////////////////////////////////////////////////////////////////////////////
-uint16_t dev_nic_tcp_checksum( uint8_t  * buffer,
-                               uint32_t   size,
-                               uint32_t   src_ip_addr,
-                               uint32_t   dst_ip_addr )
+static uint16_t dev_nic_tcp_checksum( uint8_t  * buffer,
+                                      uint32_t   tcp_length,
+                                      uint32_t   src_ip_addr,
+                                      uint32_t   dst_ip_addr )
 {
     uint32_t   i;           
@@ -182 +328 @@
     // compute max & buf
     buf = (uint16_t *)buffer;
-    max = size >> 1;
+    max = tcp_length >> 1;
 
     // extend buffer[] if required
-    if( size & 1 )
+    if( tcp_length & 1 )
     {
         max++;
-        buffer[size] = 0;
+        buffer[tcp_length] = 0;
     }
 
     // compute checksum for TCP segment
-    for( i = 0 , cs = 0 ; i < size ; i++ )  cs += buf[i];
+    for( i = 0 , cs = 0 ; i < tcp_length ; i++ )  cs += buf[i];
 
     // complete checksum for pseudo-header
@@ -198 +344 @@
     cs += dst_ip_addr;
     cs += PROTOCOL_TCP;
-    cs += size;
+    cs += tcp_length;
 
     // handle carry
@@ -213 +359 @@
 }
 
-//////////////////////////////////
-void dev_nic_init( chdev_t * nic )
+///////////////////////////////////////////////////////////////////////////////////////////
+// This static function can be called by the NIC_TX or NIC_RX server threads to unblock
+// the TX client thread after completion (success or error) of a TX command registered
+// in a socket identified by the <socket_xp> argument. The <status> argument defines
+// the command success/failure status: a null value signals a success, a non-null value
+// signals a failure. For all commands, it copies the status value in the tx_sts field,
+// and print an error message on TXT0 in case of failure.
+///////////////////////////////////////////////////////////////////////////////////////////
+// @ socket_xp  : [in] extended pointer on socket
+// @ status     : [in] command status (see above)
+///////////////////////////////////////////////////////////////////////////////////////////
+static void dev_nic_unblock_tx_client( xptr_t   socket_xp,
+                                       int32_t  status )
 {
-    // get "channel" & "is_rx" fields from chdev descriptor
-    uint32_t  channel = nic->channel;
-    bool_t    is_rx   = nic->is_rx;
-
-    // set chdev name
-    if( is_rx ) snprintf( nic->name , 16 , "nic%d_rx" , channel );
-    else        snprintf( nic->name , 16 , "nic%d_tx" , channel );
-
-    // call driver init function
-    hal_drivers_nic_init( nic );
-
-    // select a core to execute the NIC server thread
-    lid_t lid = cluster_select_local_core( local_cxy );
-
-    // bind the NIC IRQ to the selected core
-    // but does NOT enable it
-    dev_pic_bind_irq( lid , nic );
-
-    // create server thread
-    thread_t * new_thread;
-    error_t    error;
-
-    error = thread_kernel_create( &new_thread,
-                                  THREAD_DEV,
-                                  &chdev_server_func,
-                                  nic,
-                                  lid ); 
-
-    assert( (error == 0) , "cannot create server thread" );
-
-    // set "server" field in chdev descriptor
-    nic->server = new_thread;
-    
-    // set "chdev" field in thread descriptor
-    new_thread->chdev = nic;
-
-    // unblock server thread
-    thread_unblock( XPTR( local_cxy , new_thread ) , THREAD_BLOCKED_GLOBAL );
-
-}  // end dev_nic_init()
-
-
-/////////////////////////////////////////////////////////////////////////////////////////
-//                 Functions implementing the SOCKET related syscalls
-/////////////////////////////////////////////////////////////////////////////////////////
-
-//////////////////////////////////////
-int dev_nic_socket( uint32_t   domain,
-                    uint32_t   type )
+    // get socket thread cluster and local pointer
+    socket_t * socket_ptr = GET_PTR( socket_xp );
+    cxy_t      socket_cxy = GET_CXY( socket_xp );
+
+    if( status != CMD_STS_SUCCESS )
+    {
+        uint32_t sock_state = hal_remote_l32( XPTR( socket_cxy , &socket_ptr->state ));
+        uint32_t cmd_type   = hal_remote_l32( XPTR( socket_cxy , &socket_ptr->tx_cmd ));
+        pid_t    pid        = hal_remote_l32( XPTR( socket_cxy , &socket_ptr->pid ));
+        fdid_t   fdid       = hal_remote_l32( XPTR( socket_cxy , &socket_ptr->fdid ));
+
+        printk("\n[ERROR] reported by %s : socket[%x,%d] / %s / cmd %s / error %s \n",
+        __FUNCTION__, pid, fdid, socket_state_str(sock_state),
+        socket_cmd_type_str(cmd_type), socket_cmd_sts_str(status) );
+    }
+
+    // set tx_sts field in socket descriptor
+    hal_remote_s32( XPTR( socket_cxy , &socket_ptr->tx_sts ) , status );
+
+    // get extended point on TX client thread
+    xptr_t client_xp = hal_remote_l64( XPTR( socket_cxy , &socket_ptr->tx_client ));
+
+    // unblock the client thread
+    thread_unblock( client_xp , THREAD_BLOCKED_IO );
+
+}  // end dev_nic_unblock_tx_client()
+
+///////////////////////////////////////////////////////////////////////////////////////////
+// This static function can be called by the NIC_TX or NIC_RX server threads to unblock
+// the RX client thread after completion (success or error) of an RX command registered
+// in a socket identified by the <socket_xp> argument. The <status> argument defines
+// the command success/failure status: a null value signals a success, a non-null value
+// signals a failure. For all commands, it copies the status value in the rx_sts field,
+// and print an error message on TXT0 in case of failure.
+///////////////////////////////////////////////////////////////////////////////////////////
+// @ socket_xp  : [in] extended pointer on socket
+// @ status     : [in] command status (see above)
+///////////////////////////////////////////////////////////////////////////////////////////
+static void dev_nic_unblock_rx_client( xptr_t   socket_xp,
+                                       int32_t  status )
 {
-    uint32_t    fdid;
-    socket_t  * socket;
-    error_t     error;
-
-    // allocate memory for the file descriptor and for the socket
-    error = socket_create( local_cxy,
-                           domain,
-                           type,
-                           &socket,    // unused here
-                           &fdid );
-
-    if( error ) return -1;
-    return fdid;
-}
-
-////////////////////////////////
-int dev_nic_bind( uint32_t fdid,
-                  uint32_t addr,
-                  uint16_t port )
-{
-    vfs_inode_type_t    type;
-    socket_t          * socket;
-    uint32_t            state;
-
-    thread_t  * this    = CURRENT_THREAD;
-    process_t * process = this->process;
-
-    // get pointers on file descriptor
-    xptr_t       file_xp  = process_fd_get_xptr( process , fdid );
-    vfs_file_t * file_ptr = GET_PTR( file_xp );
-    cxy_t        file_cxy = GET_CXY( file_xp );
-
-    // check file_xp
-    if( file_xp == XPTR_NULL )
+    // get socket thread cluster and local pointer
+    socket_t * socket_ptr = GET_PTR( socket_xp );
+    cxy_t      socket_cxy = GET_CXY( socket_xp );
+
+    if( status != CMD_STS_SUCCESS )
     {
-        printk("\n[ERROR] in %s : undefined fdid %d",
-        __FUNCTION__, fdid );
-        return -1;
+        uint32_t sock_state = hal_remote_l32( XPTR( socket_cxy , &socket_ptr->state ));
+        uint32_t cmd_type   = hal_remote_l32( XPTR( socket_cxy , &socket_ptr->rx_cmd ));
+        pid_t    pid        = hal_remote_l32( XPTR( socket_cxy , &socket_ptr->pid ));
+        fdid_t   fdid       = hal_remote_l32( XPTR( socket_cxy , &socket_ptr->fdid ));
+
+        printk("\n[ERROR] reported by %s : socket[%x,%d] / %s / cmd %s / error %s\n",
+        __FUNCTION__, pid, fdid, socket_state_str(sock_state),
+        socket_cmd_type_str(cmd_type), socket_cmd_sts_str(status) );
     }
 
-    type   = hal_remote_l32( XPTR( file_cxy , &file_ptr->type ) );
-    socket = hal_remote_lpt( XPTR( file_cxy , &file_ptr->socket ) );
-
-    // check file descriptor type
-    if( type != INODE_TYPE_SOCK )
-    {
-        printk("\n[ERROR] in %s : illegal file type %s",
-        __FUNCTION__, vfs_inode_type_str( type ) );
-        return -1;
-    }
-
-    state = (type == SOCK_STREAM) ? TCP_STATE_BOUND : UDP_STATE_BOUND;
-
-    // update the socket descriptor
-    hal_remote_s32( XPTR( file_cxy , &socket->local_addr ) , addr );
-    hal_remote_s32( XPTR( file_cxy , &socket->local_port ) , port );
-    hal_remote_s32( XPTR( file_cxy , &socket->state      ) , state );
-
-    return 0;
-
-}  // end dev_nic_bind()
-
-//////////////////////////////////
-int dev_nic_listen( uint32_t fdid,
-                    uint32_t max_pending )
-{
-    xptr_t              file_xp;
-    vfs_file_t        * file_ptr;
-    cxy_t               file_cxy;
-    vfs_inode_type_t    file_type;
-    socket_t          * socket_ptr;
-    uint32_t            socket_type;
-    uint32_t            socket_state;
-
-    thread_t  * this    = CURRENT_THREAD;
-    process_t * process = this->process;
-
-    if( max_pending != 0 )
-    {
-        printk("\n[WARNING] in %s : max_pending argument non supported\n",
-        __FUNCTION__ );
-    }
-
-    // get pointers on file descriptor
-    file_xp  = process_fd_get_xptr( process , fdid );
-    file_ptr = GET_PTR( file_xp );
-    file_cxy = GET_CXY( file_xp );
-
-    // check file_xp
-    if( file_xp == XPTR_NULL )
-    {
-        printk("\n[ERROR] in %s : undefined fdid %d",
-        __FUNCTION__, fdid );
-        return -1;
-    }
-
-    file_type  = hal_remote_l32( XPTR( file_cxy , &file_ptr->type ) );
-    socket_ptr = hal_remote_lpt( XPTR( file_cxy , &file_ptr->socket ) );
-
-    // check file descriptor type
-    if( file_type != INODE_TYPE_SOCK )
-    {
-        printk("\n[ERROR] in %s : illegal file type %s",
-        __FUNCTION__, vfs_inode_type_str(file_type) );
-        return -1;
-    }
-
-    // get socket type and state
-    socket_type  = hal_remote_l32( XPTR( file_cxy , &socket_ptr->type )); 
-    socket_state = hal_remote_l32( XPTR( file_cxy , &socket_ptr->state )); 
-
-    // check socket type 
-    if( socket_type != SOCK_STREAM )
-    {
-        printk("\n[ERROR] in %s : illegal socket type",
-        __FUNCTION__ );
-        return -1;
-    }
-    
-    // check socket state
-    if( socket_state != TCP_STATE_BOUND )
-    {
-        printk("\n[ERROR] in %s : illegal socket state %s",
-        __FUNCTION__, socket_state_str(socket_state) );
-        return -1;
-    }
-    
-    // update socket.state
-    hal_remote_s32( XPTR( file_cxy , &socket_ptr->state ) , TCP_STATE_LISTEN );
-
-    return 0;
-
-}  // end dev_nic_listen()
-
-///////////////////////////////////
-int dev_nic_connect( uint32_t fdid,
-                     uint32_t remote_addr,
-                     uint16_t remote_port )
-{
-    vfs_inode_type_t    file_type;
-    socket_t          * socket;
-    uint32_t            socket_state;     // socket state
-    uint32_t            socket_type;      // socket type  
-    uint32_t            local_addr;       // local IP address
-    uint32_t            local_port;       // local port
-    xptr_t              tx_server_xp;     // extended pointer on TX server thread
-    thread_t          * tx_server_ptr;    // local pointer on TX server thread
-
-    thread_t  * this    = CURRENT_THREAD;
-    process_t * process = this->process;
-
-    // get pointers on file descriptor
-    xptr_t       file_xp  = process_fd_get_xptr( process , fdid );
-    vfs_file_t * file_ptr = GET_PTR( file_xp );
-    cxy_t        file_cxy = GET_CXY( file_xp );
-
-    // check file_xp
-    if( file_xp == XPTR_NULL )
-    {
-        printk("\n[ERROR] in %s : undefined fdid %d",
-        __FUNCTION__, fdid );
-        return -1;
-    }
-
-    file_type = hal_remote_l32( XPTR( file_cxy , &file_ptr->type ) );
-    socket    = hal_remote_lpt( XPTR( file_cxy , &file_ptr->socket ) );
-
-    // check file descriptor type
-    if( file_type != INODE_TYPE_SOCK )
-    {
-        printk("\n[ERROR] in %s : illegal file type %s",
-        __FUNCTION__, vfs_inode_type_str( file_type ) );
-        return -1;
-    }
-
-    // get relevant socket infos
-    socket_type   = hal_remote_l32( XPTR( file_cxy , &socket->type ) );
-    socket_state  = hal_remote_l32( XPTR( file_cxy , &socket->state ) );
-    local_addr    = hal_remote_l32( XPTR( file_cxy , &socket->local_addr ) );
-    local_port    = hal_remote_l32( XPTR( file_cxy , &socket->local_port ) );
-
-    if( socket_type == SOCK_DGRAM )       // UDP
-    {
-        if( socket_state != UDP_STATE_BOUND )
-        {
-            printk("\n[ERROR] in %s : illegal socket statea %s for CONNECT",
-            __FUNCTION__, socket_state_str(socket_state) );
-            return -1;
-        }
-    }
-    else if( socket_type == SOCK_STREAM )  // TCP
-    {
-        if( socket_state != TCP_STATE_BOUND )
-        {
-            printk("\n[ERROR] in %s : illegal socket state %s for CONNECT",
-            __FUNCTION__, socket_state_str(socket_state) );
-            return -1;
-        }
-    }
-    else
-    {
-        printk("\n[ERROR] in %s : illegal socket type %d for CONNECT",
-        __FUNCTION__, socket_type );
-        return -1;
-    }
-
-    // compute nic_channel index from remote_addr and remote_port
-    uint32_t nic_channel = dev_nic_channel_index( remote_addr , remote_port );
-
-    // link new socket to chdev servers
-    socket_link_to_servers( XPTR( file_cxy , socket ),
-                            nic_channel );
-
-    // update the socket descriptor
-    hal_remote_s32( XPTR( file_cxy , &socket->remote_addr ) , remote_addr  );
-    hal_remote_s32( XPTR( file_cxy , &socket->remote_port ) , remote_port  );
-    hal_remote_s32( XPTR( file_cxy , &socket->nic_channel ) , nic_channel  );
-
-    // the actual connection mechanism depends on socket type
-    // UDP : client thread directly updates the local socket state
-    // TCP : client thread request TX server thread to start the 3 steps handshake
-
-    if( socket_type == SOCK_DGRAM )  // UDP
-    {
-        // directly update the local socket state
-        hal_remote_s32( XPTR( file_cxy , &socket->state ) , UDP_STATE_CONNECT );
-    }
-    else                             // TCP
-    {
-        // get pointers on NIC_TX[index] chdev
-        xptr_t    tx_chdev_xp  = chdev_dir.nic_tx[nic_channel];
-        chdev_t * tx_chdev_ptr = GET_PTR( tx_chdev_xp );
-        cxy_t     tx_chdev_cxy = GET_CXY( tx_chdev_xp );
-
-        // get pointers on NIC_TX[channel] server thread
-        tx_server_ptr = hal_remote_lpt( XPTR( tx_chdev_cxy , &tx_chdev_ptr->server ));
-        tx_server_xp  = XPTR( tx_chdev_cxy , tx_server_ptr );
-
-        // register command arguments in socket descriptor
-        hal_remote_s64( XPTR( file_cxy , &socket->tx_cmd ),
-                        SOCKET_TX_CONNECT );
-
-        // update the "tx_client" field in socket descriptor
-        hal_remote_s64( XPTR( file_cxy , &socket->tx_client ),
-                        XPTR( local_cxy , this ) );
-
-        // unblock NIC_TX server thread
-        thread_unblock( tx_server_xp , THREAD_BLOCKED_CLIENT );
- 
-        // block on THREAD_BLOCKED_IO condition and deschedules
-        thread_block( XPTR( local_cxy , this ) , THREAD_BLOCKED_IO );
-        sched_yield( "blocked in connect" );
-
-        // reset the "tx_client" field in socket descriptor
-        hal_remote_s64( XPTR( file_cxy , &socket->tx_client ),
-                        XPTR_NULL );
-    }
-
-    return 0;
-
-}  // end dev_nic_connect()
-
-////////////////////////////////////
-int dev_nic_accept( uint32_t   fdid,
-                    uint32_t * remote_addr,
-                    uint16_t * remote_port )
-{
-    xptr_t              file_xp;             // extended pointer on remote file
-    vfs_file_t        * file_ptr;
-    cxy_t               file_cxy;
-    vfs_inode_type_t    file_type;           // file descriptor type
-    socket_t          * socket;              // local pointer on remote waiting socket
-    uint32_t            socket_type;         // waiting socket type    
-    uint32_t            socket_state;        // waiting socket state
-    uint32_t            socket_domain;       // waiting socket domain
-    uint32_t            socket_local_addr;   // waiting socket local IP address
-    uint32_t            socket_local_port;   // waiting socket local port
-    xptr_t              crqq_xp;             // extended pointer on socket.crqq queue
-    socket_t          * new_socket;          // local pointer on new socket
-    uint32_t            new_fdid;            // new socket file descriptor index
-    sockaddr_t          new_sockaddr;        // one request in crqq queue
-    uint32_t            new_remote_addr;     // new socket remote IP address
-    uint32_t            new_remote_port;     // new socket remote port
-    error_t             error;
-
-    thread_t  * this    = CURRENT_THREAD;
-    process_t * process = this->process;
-
-    // get pointers on file descriptor
-    file_xp  = process_fd_get_xptr( process , fdid );
-    file_ptr = GET_PTR( file_xp );
-    file_cxy = GET_CXY( file_xp );
-
-    // check file_xp
-    if( file_xp == XPTR_NULL )
-    {
-        printk("\n[ERROR] in %s : undefined fdid %d",
-        __FUNCTION__, fdid );
-        return -1;
-    }
-
-    file_type = hal_remote_l32( XPTR( file_cxy , &file_ptr->type ) );
-    socket    = hal_remote_lpt( XPTR( file_cxy , &file_ptr->socket ) );
-
-    // check file descriptor type
-    if( file_type != INODE_TYPE_SOCK )
-    {
-        printk("\n[ERROR] in %s : illegal file type %s / thread[%x,%x]\n",
-        __FUNCTION__, vfs_inode_type_str(file_type), process->pid, this->trdid );
-        return -1;
-    }
-
-    // get socket type, domain, state, local_addr and local_port
-    socket_type       = hal_remote_l32( XPTR( file_cxy , &socket->type )); 
-    socket_state      = hal_remote_l32( XPTR( file_cxy , &socket->state )); 
-    socket_domain     = hal_remote_l32( XPTR( file_cxy , &socket->domain )); 
-    socket_local_addr = hal_remote_l32( XPTR( file_cxy , &socket->local_addr )); 
-    socket_local_port = hal_remote_l32( XPTR( file_cxy , &socket->local_port )); 
-
-    // check socket type 
-    if( socket_type != SOCK_STREAM )
-    {
-        printk("\n[ERROR] in %s : illegal socket type / thread[%x,%x]\n",
-        __FUNCTION__, process->pid , this->trdid );
-        return -1;
-    }
-    
-    // check socket state
-    if( socket_state != TCP_STATE_LISTEN ) 
-    {
-        printk("\n[ERROR] in %s : illegal socket state %s / thread[%x,%x]\n",
-        __FUNCTION__, socket_state_str(socket_state), process->pid, this->trdid );
-        return -1;
-    }
-    
-    // select a cluster for the new socket
-    cxy_t new_cxy = cluster_random_select();
-
-    // allocate memory for the new socket descriptor 
-    error = socket_create( new_cxy,
-                           socket_domain,
-                           socket_type,
-                           &new_socket,
-                           &new_fdid );
-    if( error )
-    {
-        printk("\n[ERROR] in %s : cannot allocate new socket / thread[%x,%x]\n",
-        __FUNCTION__, process->pid, this->trdid );
-        return -1;
-    }
-   
-    // build extended pointer on socket.crqq
-    crqq_xp  = XPTR( file_cxy , &socket->crqq );
-
-    // blocks and deschedules if requests queue empty
-    if( remote_buf_status( crqq_xp ) == 0 )
-    {
-        thread_block( XPTR( local_cxy , this ) , THREAD_BLOCKED_IO );
-        sched_yield( "socket.crqq queue empty");
-    }
-        
-    // extract first request from the socket.crqq queue
-    remote_buf_get_to_kernel( crqq_xp,
-                              (uint8_t *)(&new_sockaddr),
-                              sizeof(sockaddr_t) );
-
-    new_remote_addr = new_sockaddr.s_addr;
-    new_remote_port = new_sockaddr.s_port;
-
-    // compute NIC channel index from remote_addr and remote_port
-    uint32_t nic_channel = dev_nic_channel_index( new_remote_addr , new_remote_port );
-
-    // update new socket descriptor 
-    new_socket->local_addr  = hal_remote_l32(XPTR( file_cxy , &socket->local_addr ));
-    new_socket->local_port  = hal_remote_l32(XPTR( file_cxy , &socket->local_port ));
-    new_socket->remote_addr = new_remote_addr;
-    new_socket->remote_port = new_remote_port;
-    new_socket->nic_channel = nic_channel;
-
-    // link new socket to chdev servers
-    socket_link_to_servers( XPTR( new_cxy , new_socket ),
-                            nic_channel );
-    // return success
-    *remote_addr = new_remote_addr;
-    *remote_port = new_remote_port;
-
-    return new_fdid;
-
-}  // end dev_nic_accept()
-
-////////////////////////////////////////////////////////////////////////////////////////
-// This static and blocking function is called by the four functions :
-// dev_nic_send() / dev_nic_recv() / dev_nic_sendto() / dev_nic_recvfrom().
-////////////////////////////////////////////////////////////////////////////////////////
-// Implementation note
-// The behavior is very different for SEND & RECV :
-// - For a SEND, the client thread checks that there is no TX command registered
-//   in the socket. It registers the command arguments in the socket descriptor
-//   (tx_client, tx_cmd, tx_buf, tx_len). Then the client thread unblocks the 
-//   TX server thread from the BLOCKED_CLIENT condition, blocks itself on the
-//   BLOCKED_IO condition, and deschedules. It is unblocked by the TX server thread
-//   when the last byte has been sent (for UDP) or acknowledged (for TCP).
-//   When the client thread resumes, it reset the command in socket, and returns.
-// - For a RECV, the client thread checks that there is no RX command registered
-//   in the socket. It registers itself in socket (rx_client). It checks the status
-//   of the receive buffer. It the rx_buf is empty, it blocks on the BLOCKED_IO
-//   condition, and deschedules. It is unblocked by the RX server thread when an UDP
-//   packet or TCP segment has been writen in the rx_buf. When it resumes, it moves
-//   the available data from the rx_buf to the user buffer, reset its registration
-//   in socket (reset the rx_buf for an UDP socket), and returns.
-////////////////////////////////////////////////////////////////////////////////////////
-int dev_nic_register_cmd( bool_t     is_send,
-                          uint32_t   fdid,
-                          uint8_t  * u_buf,
-                          uint32_t   length,
-                          bool_t     explicit,
-                          uint32_t   explicit_addr,
-                          uint32_t   explicit_port )
-{
-    vfs_inode_type_t    file_type;       // file descriptor type
-    socket_t          * socket_ptr;      // local pointer on socket descriptor
-    uint32_t            socket_state;    // current socket state
-    uint32_t            socket_type;     // socket type (UDP/TCP)
-    uint32_t            nic_channel;     // NIC channel for this socket
-    xptr_t              socket_lock_xp;  // extended pointer on socket lock
-    xptr_t              file_xp;         // extended pointer on file descriptor
-    vfs_file_t        * file_ptr;
-    cxy_t               file_cxy;
-    xptr_t              chdev_xp;        // extended pointer on NIC_TX[channel] chdev
-    chdev_t           * chdev_ptr;
-    cxy_t               chdev_cxy;
-    uint32_t            remote_addr;
-    uint32_t            remote_port;
-    uint32_t            status;          // number of bytes in rx_buf
-    int32_t             moved_bytes;     // total number of moved bytes (fot return)
-    xptr_t              server_xp;       // extended pointer on NIC_TX / NIC_RX server thread
-    thread_t          * server_ptr;      // local pointer on NIC_TX / NIC_RX server thread
-
-    thread_t  * this    = CURRENT_THREAD;
-    process_t * process = this->process;
-
-    // get pointers on file descriptor identifying the socket
-    file_xp  = process_fd_get_xptr( process , fdid );
-    file_ptr = GET_PTR( file_xp );
-    file_cxy = GET_CXY( file_xp );
-
-    if( file_xp == XPTR_NULL )
-    {
-        printk("\n[ERROR] in %s : undefined fdid %d / thread%x,%x]\n",
-        __FUNCTION__, fdid , process->pid, this->trdid );
-        return -1;
-    }
- 
-    // get file type and socket pointer
-    file_type  = hal_remote_l32( XPTR( file_cxy , &file_ptr->type ) );
-
-    // get local pointer on socket
-    socket_ptr = hal_remote_lpt( XPTR( file_cxy , &file_ptr->socket ) );
-
-    // check file descriptor type
-    if( file_type != INODE_TYPE_SOCK )
-    {
-        printk("\n[ERROR] in %s : illegal file type %s / fdid %d / thread%x,%x]\n",
-        __FUNCTION__, vfs_inode_type_str(file_type), fdid, process->pid, this->trdid );
-        return -1;
-    }
-
-    // build extended pointer on file lock protecting socket 
-    socket_lock_xp = XPTR( file_cxy , &file_ptr->lock );
-
-    // take the socket lock
-    remote_rwlock_wr_acquire( socket_lock_xp );
-
-    // get socket type, state, and channel
-    socket_type  = hal_remote_l32( XPTR( file_cxy , &socket_ptr->type ));
-    socket_state = hal_remote_l32( XPTR( file_cxy , &socket_ptr->state ));
-    nic_channel  = hal_remote_l32( XPTR( file_cxy , &socket_ptr->nic_channel ));
-
-    // check socket state / type
-    if( socket_type == SOCK_STREAM )     // TCP socket
-    {
-        if( socket_state != TCP_STATE_ESTAB )
-        {
-            printk("\n[ERROR] in %s : illegal SEND/RECV for state %s / thread%x,%x]\n",
-            __FUNCTION__, socket_state_str(socket_state), process->pid, this->trdid );
-            return -1;
-        }
-
-        if( explicit )
-        {
-            // get remote IP address and type from socket descriptor
-            remote_addr = hal_remote_l32( XPTR( file_cxy , &socket_ptr->remote_addr ));
-            remote_port = hal_remote_l32( XPTR( file_cxy , &socket_ptr->remote_port ));
-
-            if( (remote_addr != explicit_addr) || (remote_port != explicit_port) )
-            {
-                printk("\n[ERROR] in %s : wrong expliciy access / thread%x,%x]\n",
-                __FUNCTION__, process->pid, this->trdid );
-                return -1;
-            }
-        }
-    }
-    else                              // UDP socket
-    {
-        if( explicit )
-        {
-            if( socket_state == UDP_STATE_UNBOUND )
-            {
-                printk("\n[ERROR] in %s : illegal SEND/RECV for state %s / thread%x,%x]\n",
-                __FUNCTION__, socket_state_str(socket_state), process->pid, this->trdid );
-                return -1;
-            }
-
-            // update remote IP address and port into socket descriptor
-            hal_remote_s32( XPTR( file_cxy , &socket_ptr->remote_addr ), explicit_addr );
-            hal_remote_s32( XPTR( file_cxy , &socket_ptr->remote_port ), explicit_port );
-        }
-        else
-        {
-            if( socket_state != UDP_STATE_CONNECT )
-            {
-                printk("\n[ERROR] in %s : illegal SEND/RECV for state %s / thread%x,%x]\n",
-                __FUNCTION__, socket_state_str(socket_state), process->pid, this->trdid );
-                return -1;
-            }
-        }
-    }
-
-    ///////////////////////////////////////////////////////
-    if( is_send )                       // SEND command
-    {
-        // build extended pointer on socket "tx_client"
-        xptr_t client_xp = XPTR( file_cxy , &socket_ptr->tx_client );
-
-        // check no previous SEND command
-        xptr_t client = hal_remote_l64( client_xp );
-
-        if( client != XPTR_NULL )  // release socket lock and return error
-        {
-            // release socket lock
-            remote_rwlock_wr_release( socket_lock_xp );
-                    
-            // get previous thread cluster & local pointer
-            cxy_t      prev_cxy = GET_CXY( client );
-            thread_t * prev_ptr = GET_PTR( client );
-
-            // get previous command type and trdid 
-            uint32_t prev_cmd = hal_remote_l32( XPTR( prev_cxy , &prev_ptr->nic_cmd.type )); 
-            uint32_t prev_tid = hal_remote_l32( XPTR( prev_cxy , &prev_ptr->trdid ));
-
-            printk("\n[ERROR] in %s : previous command %s for thread %x / thread%x,%x]\n",
-            __FUNCTION__, socket_cmd_str(prev_cmd), prev_tid,
-            process->pid, this->trdid );
-
-            return -1;
-        }
-
-        // client thread registers in socket descriptor
-        hal_remote_s64( client_xp , XPTR( local_cxy , this ) );
-        hal_remote_s32( XPTR( file_cxy , &socket_ptr->tx_cmd  ) , SOCKET_TX_SEND );
-        hal_remote_spt( XPTR( file_cxy , &socket_ptr->tx_buf  ) , u_buf );
-        hal_remote_s32( XPTR( file_cxy , &socket_ptr->tx_len  ) , length );
-        hal_remote_s32( XPTR( file_cxy , &socket_ptr->tx_todo ) , length );
-
-        // release socket lock
-        remote_rwlock_wr_release( socket_lock_xp );
-                    
-        // get pointers on relevant chdev
-        chdev_xp  = chdev_dir.nic_tx[nic_channel];
-        chdev_ptr = GET_PTR( chdev_xp );
-        chdev_cxy = GET_CXY( chdev_xp );
-
-        // get pointers on NIC_TX[channel] server thread
-        server_ptr = hal_remote_lpt( XPTR( chdev_cxy , &chdev_ptr->server ));
-        server_xp  = XPTR( chdev_cxy , server_ptr );
-
-        // unblocks the NIC_TX server thread
-        thread_unblock( server_xp , THREAD_BLOCKED_CLIENT );
-
-        // client thread blocks itself and deschedules
-        thread_block( XPTR( local_cxy , this ) , THREAD_BLOCKED_IO );
-        sched_yield( "blocked in nic_io" );
-
-        // take the socket lock when unblocked
-        remote_rwlock_wr_acquire( socket_lock_xp );
-
-        // unlink client thread from socket 
-        hal_remote_s64( client_xp , XPTR_NULL );
-                    
-        // release socket lock
-        remote_rwlock_wr_release( socket_lock_xp );
-                    
-        // exit waiting loop and return
-        return length;
-
-    }  // end SEND
-
-    ////////////////////////////////////////////////////////
-    else                                 // RECV command
-    {
-        // build extended pointers on socket "rx_client"
-        xptr_t client_xp = XPTR( file_cxy , &socket_ptr->rx_client );
-
-        // check no previous RECV command
-        xptr_t client = hal_remote_l64( client_xp );
-
-        if( client != XPTR_NULL )  // release socket lock and return error
-        {
-            // release socket lock
-            remote_rwlock_wr_release( socket_lock_xp );
-                    
-            // get previous thread cluster & local pointer
-            cxy_t      prev_cxy = GET_CXY( client );
-            thread_t * prev_ptr = GET_PTR( client );
-
-            // get previous command type and trdid 
-            uint32_t prev_cmd = hal_remote_l32( XPTR( prev_cxy , &prev_ptr->nic_cmd.type )); 
-            uint32_t prev_tid = hal_remote_l32( XPTR( prev_cxy , &prev_ptr->trdid ));
-
-            printk("\n[ERROR] in %s : previous command %s for thread %x / thread%x,%x]\n",
-            __FUNCTION__, socket_cmd_str(prev_cmd), prev_tid, process->pid, this->trdid );
-            return -1;
-        }
-
-        // build extended pointer on "rx_buf"
-        xptr_t rx_buf_xp = XPTR( file_cxy , &socket_ptr->rx_buf );
-
-        // get rx_buf status from socket
-        status = remote_buf_status( rx_buf_xp );
-
-        if( status == 0 )    // rx_buf empty => blocks and deschedules
-        { 
-            // release socket lock
-            remote_rwlock_wr_release( socket_lock_xp );
-                 
-            // client thread blocks itself and deschedules
-            thread_block( XPTR( local_cxy , this ) , THREAD_BLOCKED_IO );
-            sched_yield( "blocked in nic_io" );
-
-            // take socket lock
-            remote_rwlock_wr_release( socket_lock_xp );
-        }
-
-        // number of moved bytes cannot be larger than u_buf size
-        moved_bytes = ( length < status ) ? length : status;
-
-        // move data from kernel rx_buf to user u_buf
-        remote_buf_get_to_user( rx_buf_xp,
-                                 u_buf,
-                                 moved_bytes );
-
-        // reset rx_buf for an UDP socket
-        if( socket_type == SOCK_DGRAM ) remote_buf_reset( rx_buf_xp );
-
-        // unlink client thread from socket 
-        hal_remote_s64( client_xp , XPTR_NULL );
-                    
-        // release socket lock
-        remote_rwlock_wr_release( socket_lock_xp );
-                    
-        // exit waiting loop and return
-        return moved_bytes;
-
-    }  // end SEND  
-
-} // end dev_nic_register_cmd()
-
-
-///////////////////////////////////
-int dev_nic_send( uint32_t    fdid,
-                  uint8_t   * u_buf,
-                  uint32_t    length )
-{
-#if DEBUG_DEV_NIC_TX
-thread_t  * this    = CURRENT_THREAD;
-process_t * process = this->process;
-trdid_t     trdid   = this->trdid;
-pid_t       pid     = process->pid;
-uint32_t cycle = (uint32_t)hal_get_cycle();
-if (DEBUG_DEV_NIC_TX < cycle )
-printk("[%s] thread[%x,%x] enters : fdid %d / buf %x / length %d / cycle %d\n",
-__FUNCTION__, pid, trdid, fdid, u_buf, length, cycle );
-#endif
-
-    error_t error = dev_nic_register_cmd( true,           // SEND
-                                          fdid,
-                                          u_buf,
-                                          length,
-                                          false, 0, 0 );  // no explicit remote socket
-#if DEBUG_DEV_NIC_TX
-cycle = (uint32_t)hal_get_cycle();
-if (DEBUG_DEV_NIC_TX < cycle )
-printk("[%s] thread[%x,%x] exit : fdid %d / cycle %d\n",
-__FUNCTION__, pid, trdid, cycle );
-#endif
-
-    return error;
-
-}  // end dev_nic_send()
-
-///////////////////////////////////
-int dev_nic_recv( uint32_t    fdid,
-                  uint8_t   * u_buf,
-                  uint32_t    length )
-{
-#if DEBUG_DEV_NIC_RX
-thread_t  * this    = CURRENT_THREAD;
-process_t * process = this->process;
-trdid_t     trdid   = this->trdid;
-pid_t       pid     = process->pid;
-uint32_t    cycle   = (uint32_t)hal_get_cycle();
-if (DEBUG_DEV_NIC_RX < cycle )
-printk("[%s] thread[%x,%x] enters : fdid %d / buf %x / length %d / cycle %d\n",
-__FUNCTION__, pid, trdid, fdid, u_buf, length, cycle );
-#endif
-
-    error_t error = dev_nic_register_cmd( false,          // RECV
-                                          fdid,
-                                          u_buf,
-                                          length,
-                                          false, 0, 0 );  // no explicit remote socket
-#if DEBUG_DEV_NIC_RX
-cycle = (uint32_t)hal_get_cycle();
-if (DEBUG_DEV_NIC_RX < cycle )
-printk("[%s] thread[%x,%x] exit : fdid %d / cycle %d\n",
-__FUNCTION__, pid, trdid, cycle );
-#endif
-
-    return error;
-
-} // end dev_nic_recv()
-
-/////////////////////////////////////
-int dev_nic_sendto( uint32_t    fdid,
-                    uint8_t   * u_buf,
-                    uint32_t    length,
-                    uint32_t    remote_addr,
-                    uint32_t    remote_port )
-{
-#if DEBUG_DEV_NIC_TX
-thread_t  * this    = CURRENT_THREAD;
-process_t * process = this->process;
-trdid_t     trdid   = this->trdid;
-pid_t       pid     = process->pid;
-uint32_t cycle = (uint32_t)hal_get_cycle();
-if (DEBUG_DEV_NIC_TX < cycle )
-printk("[%s] thread[%x,%x] enters : fdid %d / buf %x / length %d / cycle %d\n",
-__FUNCTION__, pid, trdid, fdid, u_buf, length, cycle );
-#endif
-
-    error_t error = dev_nic_register_cmd( true,          // SEND
-                                          fdid,
-                                          u_buf,
-                                          length,
-                                          true,          // explicit remote socket
-                                          remote_addr,
-                                          remote_port );
-#if DEBUG_DEV_NIC_TX
-cycle = (uint32_t)hal_get_cycle();
-if (DEBUG_DEV_NIC_TX < cycle )
-printk("[%s] thread[%x,%x] exit : fdid %d / cycle %d\n",
-__FUNCTION__, pid, trdid, cycle );
-#endif
-
-    return error;
-
-}  // end dev_nic_sendto()
-
-///////////////////////////////////////
-int dev_nic_recvfrom( uint32_t    fdid,
-                      uint8_t   * u_buf,
-                      uint32_t    length,
-                      uint32_t    remote_addr,
-                      uint32_t    remote_port )
-{
-#if DEBUG_DEV_NIC_RX
-thread_t  * this    = CURRENT_THREAD;
-process_t * process = this->process;
-trdid_t     trdid   = this->trdid;
-pid_t       pid     = process->pid;
-uint32_t    cycle   = (uint32_t)hal_get_cycle();
-if (DEBUG_DEV_NIC_RX < cycle )
-printk("[%s] thread[%x,%x] enters : fdid %d / buf %x / length %d / cycle %d\n",
-__FUNCTION__, pid, trdid, fdid, u_buf, length, cycle );
-#endif
-
-    error_t error = dev_nic_register_cmd( false,         // RECV
-                                          fdid,
-                                          u_buf,
-                                          length,
-                                          true,          // explicit remote socket
-                                          remote_addr,
-                                          remote_port );
-#if DEBUG_DEV_NIC_RX
-cycle = (uint32_t)hal_get_cycle();
-if (DEBUG_DEV_NIC_RX < cycle )
-printk("[%s] thread[%x,%x] exit : fdid %d / cycle %d\n",
-__FUNCTION__, pid, trdid, cycle );
-#endif
-
-    return error;
-
-}  // end dev_nic_recvfrom()
-
-
-
-
-
+    // set rx_sts field in socket descriptor
+    hal_remote_s32( XPTR( socket_cxy , &socket_ptr->rx_sts ) , status );
+
+    // get extended point on RX client thread
+    xptr_t client_xp = hal_remote_l64( XPTR( socket_cxy , &socket_ptr->rx_client ));
+
+    // unblock the client thread
+    thread_unblock( client_xp , THREAD_BLOCKED_IO );
+
+}  // end dev_nic_unblock_rx_client()
 
 
@@ -1080 +446 @@
 //               Functions called by the NIC_RX server thread
 ///////////////////////////////////////////////////////////////////////////////////////////
-
-/////////////////////////////////////////////////////////////////////////////////////////
-// This static function is called by the NIC_RX[channel] server thread to register
-// a send request defined by the <flags> argument in the R2T queue  specified by 
-// the <queue_xp> argument.
-/////////////////////////////////////////////////////////////////////////////////////////
-// @ queue_xp   : [in] extended pointer on the R2T qeue descriptor.
-// @ flags      : [in] flags to be set in the TCP segment.
-/////////////////////////////////////////////////////////////////////////////////////////
-static void dev_nic_rx_put_r2t_request( xptr_t    queue_xp,
-                                        uint32_t  flags )
-{
-    while( 1 )
-    {
-        error_t error = remote_buf_put_from_kernel( queue_xp,
-                                                    (uint8_t *)(&flags),
-                                                    1 );
-
-        if( error )  sched_yield( "waiting R2T queue" );
-        else         break;
-    }
-
-}  // end dev_nic_rx_put_r2t_request()
-  
-///////////////////////////////////////////////////////////////////////////////////////////
-// This static function is called by the dev_nic_rx_server() function.
-// It calls directly the NIC driver (with the READABLE command) and returns the status
-// of the NIC_RX queue identified by the <chdev> argument.
-// in the <readable> buffer.
-///////////////////////////////////////////////////////////////////////////////////////////
-// @ chdev     : [in]  local pointer on NIC_TX chdev.
-// @ readable  : [out] zero if queue empty.  
-// @ returns 0 if success / returns -1 if failure in accessing NIC device.
-///////////////////////////////////////////////////////////////////////////////////////////
-error_t dev_nic_rx_queue_readable( chdev_t  * chdev,
-                                   uint32_t * readable )
-{
-    thread_t * this = CURRENT_THREAD;
-
-    // initialize NIC_READABLE command in thread descriptor
-    this->nic_cmd.dev_xp = XPTR( local_cxy , chdev );
-    this->nic_cmd.type   = NIC_CMD_READABLE;
-
-    // call driver to test readable
-    chdev->cmd( XPTR( local_cxy , this ) );
-
-    // return status
-    *readable = this->nic_cmd.status;
-
-    // return error
-    return this->nic_cmd.error;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////
-// This static function is called by the dev_nic_rx_server() function.
-// It moves one Ethernet packet from the NIC_RX_QUEUE identified the <chdev> argument,
-// to the 2K bytes kernel buffer identified by the <buffer> argument. The actual
-// Ethernet packet length is returned in the <length> argument.
-// It calls directly the NIC driver with the READ command, without registering in the
-// waiting queue, because only the NIC_RX server thread can access this NIC_RX_QUEUE.
-///////////////////////////////////////////////////////////////////////////////////////////
-// @ chdev   : [in]  local pointer on NIC_TX chdev.
-// @ buffer  : [in]  local pointer on destination kernel buffer.
-// @ length  : [out] Ethernet packet size in bytes.
-// @ returns 0 if success / returns -1 if failure in accessing NIC device.
-///////////////////////////////////////////////////////////////////////////////////////////
-error_t dev_nic_rx_move_packet( chdev_t  * chdev,
-                                uint8_t  * k_buf,
-                                uint32_t * length )
-{
-    thread_t * this = CURRENT_THREAD;
-
-#if DEBUG_DEV_NIC_RX
-uint32_t cycle = (uint32_t)hal_get_cycles();
-if( DEBUG_DEV_NIC_RX < cycle )
-printk("\n[%s] thread[%x,%x] enters / cycle %d\n", 
-__FUNCTION__, this->process->pid, this->trdid, cycle );
-#endif
-
-    // initialize NIC_READ command in thread descriptor
-    this->nic_cmd.type    = NIC_CMD_READ;
-    this->nic_cmd.buffer  = k_buf;
-
-    // call NIC driver  
-    chdev->cmd( XPTR( local_cxy , this ) );
-
-    // returns packet length   
-    *length = this->nic_cmd.length;
-
-    // check error
-    if( this->nic_cmd.error ) 
-    {
-
-#if DEBUG_DEV_NIC_RX
-cycle = (uint32_t)hal_get_cycles();
-if( DEBUG_DEV_NIC_RX < cycle )
-printk("\n[%s] thread[%x,%x] exit / ERROR in NIC_RX / cycle %d\n", 
-__FUNCTION__, this->process->pid, this->trdid, cycle );
-#endif
-
-        return -1;
-    }
-    else
-    {
-
-#if DEBUG_DEV_NIC_RX
-cycle = (uint32_t)hal_get_cycles();
-if( DEBUG_DEV_NIC_RX < cycle )
-printk("\n[%s] thread[%x,%x] exit / SUCCESS / cycle %d\n", 
-__FUNCTION__, this->process->pid, this->trdid, cycle );
-#endif
-
-        return 0;
-    }
-
-}   // end dev_nic_rx_move_packet()
 
 ///////////////////////////////////////////////////////////////////////////////////////////
@@ -1237 +487 @@
                                     uint32_t * trsp_protocol )
 {
+
+#if DEBUG_DEV_NIC_RX
+thread_t * this  = CURRENT_THREAD;
+uint32_t   cycle = (uint32_t)hal_get_cycles();
+#endif
+
+    // get packet length
     uint32_t length = ((uint32_t)buffer[2] << 8) | (uint32_t)buffer[3];
 
-    // discard packet if eth_length != ip_length
+    // discard packet if eth_payload_length != ip_length
     if( length != expected_length )
     {
 
-#if DEBUG_NIC_DEV
-thread_t * this = CURRENT_THREAD;
-printk("\n[%s] thread[%x,%x] enters : length (%d) != expected_length (%d)\n",
+#if DEBUG_DEV_NIC_RX
+if( DEBUG_DEV_NIC_RX < cycle )
+printk("\n[%s] thread[%x,%x] failure : length (%d) != expected_length (%d)\n",
 __FUNCTION__, this->process->pid, this->trdid, length, expected_length );
 #endif
-
         return -1;
     }
 
+    // get transport protocol type
+    uint8_t protocol = buffer[9];
+
+    // discard packet if unsupported protocol 
+    if( (protocol != PROTOCOL_TCP) && (protocol != PROTOCOL_UDP) )
+    {
+
+#if DEBUG_DEV_NIC_RX
+if( DEBUG_DEV_NIC_RX < cycle )
+printk("\n[%s] thread[%x,%x] failure : unsupported transport protocol (%d)\n",
+__FUNCTION__, this->process->pid, this->trdid, protocol );
+#endif
+        return -1;
+
+    }
     // compute IP header checksum 
-    uint32_t received_cs = (uint32_t)dev_nic_ip_checksum( buffer );
+    uint32_t computed_cs = (uint32_t)dev_nic_ip_checksum( buffer );
 
     // extract IP header checksum
-    uint32_t computed_cs = ((uint32_t)buffer[10] << 8) | ((uint32_t)buffer[11]);
+    uint32_t received_cs = ((uint32_t)buffer[10] << 8) | ((uint32_t)buffer[11]);
 
     // discard packet if bad checksum
@@ -1262 +533 @@
     {
 
-#if DEBUG_NIC_DEV
-thread_t * this = CURRENT_THREAD;
-printk("\n[%s] thread[%x,%x] computed checksum (%d) != received checksum (%d)\n",
+#if DEBUG_DEV_NIC_RX
+if( DEBUG_DEV_NIC_RX < cycle )
+printk("\n[%s] thread[%x,%x] failure : computed checksum (%d) != received checksum (%d)\n",
 __FUNCTION__, this->process->pid, this->trdid, computed_cs, received_cs );
 #endif
-
         return -1;
     }
@@ -1282 +552 @@
                    ((uint32_t)buffer[19]      ) ;
 
-    *trsp_protocol = (uint32_t)buffer[9];
+    *trsp_protocol = protocol;
    
     return 0;
@@ -1354 +624 @@
     if( xlist_is_empty( root_xp ) ) return;
  
-    // take the tock protecting the sockets list
+    // take the lock protecting the sockets list
     remote_busylock_acquire( lock_xp );
 
@@ -1387 +657 @@
                               (remote_port == pkt_src_port);
 
-        if (socket_state == UDP_STATE_CONNECT ) match_socket = local_match && remote_match;
-        else                                    match_socket = local_match;
+        if (socket_state == UDP_STATE_ESTAB ) match_socket = local_match && remote_match;
+        else                                  match_socket = local_match;
 
         // exit loop when socket found
@@ -1406 +676 @@
 
     // take the lock protecting the socket 
-    remote_rwlock_wr_acquire( socket_lock_xp );
+    remote_queuelock_acquire( socket_lock_xp );
 
     // get status & space from rx_buf
@@ -1425 +695 @@
                                  k_buf + UDP_HEAD_LEN,
                                  moved_bytes );
-
-    // unblock client thread if registered
+    // unblock client thread 
     if( client_xp != XPTR_NULL )
     {
@@ -1433 +702 @@
 
     // release the lock protecting the socket
-    remote_rwlock_wr_release( socket_lock_xp );
+    remote_queuelock_release( socket_lock_xp );
 
 }  // end dev_nic_rx_handle_udp_packet()
@@ -1440 +709 @@
 // This static function is called by the dev_nic_rx_server() function to handle one RX
 // TCP segment contained in a kernel buffer defined by the <k_buf> & <k_length> arguments.
-// It the received segment doesn't match an existing local socket, or is corrupted,
-// this faulty segment is discarded. 
+// The <seg_remote_addr> and <seg_local_addr> arguments are obtained from the received
+// IP packet header. It the received segment doesn't match any connected socket attached
+// to the selected chdev[k], or any listening socket waiting connection, or if the segment
+// is corrupted, this segment is discarded. 
+// If required by the TCP flags, it registers an R2T request in the socket R2T queue 
+// to implement the TCP handcheck for close and connect.
 ///////////////////////////////////////////////////////////////////////////////////////////
 // Implementation note:
-// 1) It checks the TCP checksum, and discard the corrupted segment.
-// 2) It scans the list of sockets attached to the RX chdev, to find the socket
-//    matching the TCP segment header, and discards the segment if no socket found.
-// 3) When a socket has been found, it takes the lock protecting the socket state,
-//    because the socket is accessed by both the NIC_TX and NIC_RX server threads.
-// 4) Depending on the socket state, it handle the received segment, including the
-//    SYN, FIN, ACK and RST flags. It updates the socket state when required, moves
-//    data to the rx_buf when possible, and registers requests to the TX server 
-//    thread in the R2T queue attached to the socket, to insert control flags in the
-//    TX stream, as required.
-// 5) Finally, it releases the lock protecting the socke and returns.
-///////////////////////////////////////////////////////////////////////////////////////////
-// @ chdev         : [in] local pointer on local NIC_RX chdev descriptor.
-// @ k_buf         : [in] pointer on the TCP packet in local kernel buffer.
-// @ k_length      : [in] number of bytes in buffer (including TCP header).
-// @ seg_src_addr  : [in] source IP address (from IP packet header).
-// @ seg_dst_addr  : [in] destination IP address (from IP packet header).
+// A "connected" socket is actually a TCP socket already attached to a given NIC_RX[k]
+// chdev, and can therefore receive a TCP segment on the NIC channel <k>. A "listening"
+// socket is a TCP socket in the LISTEN state. This function operates in 6 steps:
+// 1) It checks the TCP checksum, and discard the corrupted segment if corrupted.
+// 2) It scans the list of sockets attached to the NIC_RX[k] chdev, to find one TCP
+//    socket matching the TCP segment header. 
+// 3) When a matching connected socket is found, it handles the received segment, including 
+//    the SYN, FIN, ACK and RST flags. It updates the socket state when required, moves 
+//    data to the rx_buf when possible, and return. It takes the lock protecting the socket,
+//    because an connected socket is accessed by both the NIC_TX and NIC_RX server threads.
+// 4) If no matching connected socket has been found, it scans the list of listening 
+//    sockets to find a matching listening socket. 
+// 5) When a matching listening socket is found, it simply registers a new connection
+//    request in the listening socket CRQ queue, when the SYN flag is set, and insert 
+//    a SYN-ACK request in the socket R2T queue.
+// 6) It discards the packet if no connected or listening socket has been found.
+///////////////////////////////////////////////////////////////////////////////////////////
+// @ chdev           : [in] local pointer on local NIC_RX chdev descriptor.
+// @ k_buf           : [in] pointer on the TCP packet in local kernel buffer.
+// @ k_length        : [in] number of bytes in buffer (including TCP header).
+// @ seg_remote_addr : [in] remote IP address (from IP packet header).
+// @ seg_local_addr  : [in] local IP address (from IP packet header).
 ///////////////////////////////////////////////////////////////////////////////////////////
 static void dev_nic_rx_handle_tcp_segment( chdev_t  * chdev,
                                            uint8_t  * k_buf,
                                            uint32_t   k_length,
-                                           uint32_t   seg_src_addr,
-                                           uint32_t   seg_dst_addr )
+                                           uint32_t   seg_remote_addr,
+                                           uint32_t   seg_local_addr )
 {
-    xptr_t     root_xp;           // extended pointer on attached sockets list root 
-    xptr_t     lock_xp;           // extended pointer on chdev lock 
-    xptr_t     iter_xp;           // iterator for these queues
-    bool_t     match_socket;      // true if socket found
-    xptr_t     socket_xp;         // extended pointer on matching socket descriptor
-    cxy_t      socket_cxy;
-    socket_t * socket_ptr;
-    uint32_t   local_addr;        // local IP address from socket
-    uint32_t   local_port;        // local port from socket
-    uint32_t   remote_addr;       // remote IP address from socket
-    uint32_t   remote_port;       // remote port from socket
-    uint32_t   socket_state;      // socket state
-    uint32_t   socket_type;       // socket type
-    uint32_t   socket_tx_nxt;    // next byte to send in TX stream
-    uint32_t   socket_tx_una;    // first unacknowledged byte in TX stream
-    uint32_t   socket_rx_nxt;    // next expected byte in RX stream
-    uint32_t   socket_rx_wnd;    // current window value in RX stream
-    xptr_t     socket_lock_xp;    // extended pointer on lock protecting socket state
-    xptr_t     socket_rx_buf_xp;  // extended pointer on socket rx_buf
-    xptr_t     socket_r2tq_xp;    // extended pointer on socket r2t queue
-    xptr_t     socket_client_xp;  // extended pointer on socket rx_client thread
-    uint16_t   checksum;          // computed TCP segment chechsum
-
-    // build extended pointer on xlist of all sockets attached to NIC_RX chdev
-    root_xp = XPTR( local_cxy , &chdev->wait_root );
-    lock_xp = XPTR( local_cxy , &chdev->wait_lock );
+    xptr_t     root_xp;            // extended pointer on connected sockets list root 
+    xptr_t     lock_xp;            // extended pointer on chdev lock 
+    xptr_t     iter_xp;            // iterator for these queues
+    bool_t     attached_match;     // true if one attached socket match 
+    bool_t     listening_match;    // true if one listening socket match
+    xptr_t     socket_xp;          // extended pointer on matching socket
+    cxy_t      socket_cxy;         // cluster identifier of matching socket
+    socket_t * socket_ptr;         // local pointer on matching socket
+    uint32_t   socket_local_addr;  // local IP address from socket
+    uint32_t   socket_local_port;  // local port from socket
+    uint32_t   socket_remote_addr; // remote IP address from socket
+    uint32_t   socket_remote_port; // remote port from socket
+    uint32_t   socket_state;       // socket state
+    uint32_t   socket_type;        // socket type
+    bool_t     socket_tx_valid;    // TX command valid
+    uint32_t   socket_tx_cmd;      // TX command type
+    uint32_t   socket_tx_todo;     // number of TX bytes not sent yet 
+    uint32_t   socket_tx_nxt;      // next byte to send in TX stream
+    uint32_t   socket_tx_una;      // first unacknowledged byte in TX stream
+    bool_t     socket_rx_valid;    // RX command valid
+    uint32_t   socket_rx_cmd;      // TX command type
+    uint32_t   socket_rx_nxt;      // next expected byte in RX stream
+    uint32_t   socket_rx_wnd;      // current window value in RX stream
+    uint32_t   socket_rx_irs;      // initial sequence index in RX stream
+    xptr_t     socket_lock_xp;     // extended pointer on lock protecting socket state
+    xptr_t     socket_rx_buf_xp;   // extended pointer on socket rx_buf
+    xptr_t     socket_r2tq_xp;     // extended pointer on socket R2T queue
+    xptr_t     socket_crqq_xp;     // extended pointer on socket CRQ queue
+    uint16_t   checksum;           // computed TCP segment chechsum
+    error_t    error;
 
     // get relevant infos from TCP segment header
-    uint32_t seg_src_port = ((uint32_t)k_buf[0] << 8) | (uint32_t)k_buf[1];
-    uint32_t seg_dst_port = ((uint32_t)k_buf[2] << 8) | (uint32_t)k_buf[3];
+    uint32_t seg_remote_port = ((uint32_t)k_buf[0] << 8) | (uint32_t)k_buf[1];
+    uint32_t seg_local_port  = ((uint32_t)k_buf[2] << 8) | (uint32_t)k_buf[3];
 
     uint32_t seg_seq_num  = ((uint32_t)k_buf[4]  << 24) | 
@@ -1509 +791 @@
                             ((uint32_t)k_buf[11]      );
 
-    uint8_t  seg_hlen     = k_buf[12] >> 2;       // TCP header length in bytes
+    uint8_t  seg_hlen     = k_buf[12] << 2;       // TCP header length in bytes
  
     uint8_t  seg_flags    = k_buf[13];
@@ -1522 +804 @@
     uint16_t seg_checksum = ((uint32_t)k_buf[16] << 8) | (uint32_t)k_buf[17];
 
-    uint32_t seg_payload  = k_length - seg_hlen;  // number of bytes in payload
-
-    // 1. compute TCP checksum
+    uint32_t seg_data_len = k_length - seg_hlen;  // number of bytes in payload
+
+#if DEBUG_DEV_NIC_RX
+thread_t * this = CURRENT_THREAD;
+uint32_t   cycle;
+uint32_t   fdid;
+pid_t      pid;
+#endif
+
+#if DEBUG_DEV_NIC_RX
+cycle = (uint32_t)hal_get_cycles();
+if( cycle > DEBUG_DEV_NIC_RX )
+printk("\n[%s] thread[%x,%x] enters / tcp_length %d / tcp_flags %x / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, k_length, seg_flags , cycle );
+#endif
+
+    // compute and check TCP checksum
+    k_buf[16] = 0;
+    k_buf[17] = 0;
     checksum = dev_nic_tcp_checksum( k_buf,
                                      k_length,
-                                     seg_src_addr,
-                                     seg_dst_addr );
+                                     seg_remote_addr,
+                                     seg_local_addr );
 
     // discard segment if corrupted 
-    if( seg_checksum != checksum ) return;
+    if( seg_checksum != checksum )
+    {
+
+#if DEBUG_DEV_NIC_RX
+if( cycle > DEBUG_DEV_NIC_RX )
+printk("\n[%s] thread[%x,%x] tcp checksum failure : received %x / computed %x\n",
+__FUNCTION__, this->process->pid, this->trdid, seg_checksum, checksum );
+#endif
+        return;
+    }
     
-    match_socket = false;
-
-    // take the lock protecting the list of sockets
+    // scan list of attached sockets to find a matching TCP socket
+    attached_match = false;
+
+    // build extended pointer on xlist of sockets attached to NIC_RX chdev
+    root_xp = XPTR( local_cxy , &chdev->wait_root );
+    lock_xp = XPTR( local_cxy , &chdev->wait_lock );
+
+    // take the lock protecting the list of attached sockets
     remote_busylock_acquire( lock_xp );
 
-    // 2. scan list of sockets to find a matching socket
     XLIST_FOREACH( root_xp , iter_xp )
     {
@@ -1554 +865 @@
 
         // get relevant socket infos for matching
-        local_addr   = hal_remote_l32(XPTR(socket_cxy , &socket_ptr->local_addr )); 
-        remote_addr  = hal_remote_l32(XPTR(socket_cxy , &socket_ptr->remote_addr )); 
-        local_port   = hal_remote_l32(XPTR(socket_cxy , &socket_ptr->local_port )); 
-        remote_port  = hal_remote_l32(XPTR(socket_cxy , &socket_ptr->remote_port )); 
+        socket_local_addr   = hal_remote_l32(XPTR(socket_cxy , &socket_ptr->local_addr )); 
+        socket_remote_addr  = hal_remote_l32(XPTR(socket_cxy , &socket_ptr->remote_addr )); 
+        socket_local_port   = hal_remote_l32(XPTR(socket_cxy , &socket_ptr->local_port )); 
+        socket_remote_port  = hal_remote_l32(XPTR(socket_cxy , &socket_ptr->remote_port )); 
                 
-        // compute matching condition
-        // (in LISTEN state, remote_port and remote_addr can be unspecified)
-        if( socket_state == TCP_STATE_LISTEN )
+        // compute matching condition for a connected socket
+        attached_match = (socket_local_addr  == seg_local_addr) && 
+                         (socket_local_port  == seg_local_port) &&
+                         (socket_remote_addr == seg_remote_addr) &&
+                         (socket_remote_port == seg_remote_port) ;
+
+        // exit loop if matching
+        if( attached_match ) 
         {
-            match_socket = (local_addr  == seg_dst_addr) && 
-                           (local_port  == seg_dst_port) ;
+
+#if DEBUG_DEV_NIC_RX
+fdid = hal_remote_l32( XPTR( socket_cxy , &socket_ptr->fdid ) );
+pid  = hal_remote_l32( XPTR( socket_cxy , &socket_ptr->pid ) );
+if( cycle > DEBUG_DEV_NIC_RX )
+printk("\n[%s] thread[%x,%x] matching attached socket[%d,%d] / state %s\n",
+__FUNCTION__, this->process->pid, this->trdid, pid, fdid, socket_state_str(socket_state) );
+#endif
+            break;
         }
-        else
+
+    }  // end loop on attached sockets
+
+    // release the lock protecting the list of attached sockets
+    remote_busylock_release( lock_xp );
+
+    // handle TCP segment for an attached socket
+    if( attached_match )
+    {
+        // The actions depend on both the socket state and the received segment flags :
+        // - update socket state,
+        // - move data to rx_buf,
+        // - register a request in R2T queue when required
+ 
+        // build extended pointers on various socket fields
+        socket_lock_xp    = XPTR( socket_cxy , &socket_ptr->lock );
+        socket_rx_buf_xp  = XPTR( socket_cxy , &socket_ptr->rx_buf );
+        socket_r2tq_xp    = XPTR( socket_cxy , &socket_ptr->r2tq );
+
+        // take the lock protecting the matching socket
+        remote_queuelock_acquire( socket_lock_xp );
+
+        // get relevant socket infos from socket descriptor
+        socket_tx_valid = hal_remote_l32(XPTR( socket_cxy , &socket_ptr->tx_valid ));
+        socket_tx_cmd   = hal_remote_l32(XPTR( socket_cxy , &socket_ptr->tx_cmd ));
+        socket_tx_todo  = hal_remote_l32(XPTR( socket_cxy , &socket_ptr->tx_todo ));
+        socket_tx_nxt   = hal_remote_l32(XPTR( socket_cxy , &socket_ptr->tx_nxt )); 
+        socket_tx_una   = hal_remote_l32(XPTR( socket_cxy , &socket_ptr->tx_una ));
+
+        socket_rx_valid = hal_remote_l32(XPTR( socket_cxy , &socket_ptr->rx_valid ));
+        socket_rx_cmd   = hal_remote_l32(XPTR( socket_cxy , &socket_ptr->rx_cmd ));
+        socket_rx_nxt   = hal_remote_l32(XPTR( socket_cxy , &socket_ptr->rx_nxt )); 
+        socket_rx_wnd   = hal_remote_l32(XPTR( socket_cxy , &socket_ptr->rx_wnd )); 
+        socket_rx_irs   = hal_remote_l32(XPTR( socket_cxy , &socket_ptr->rx_irs ));
+
+        // handle the received segment, depending on the matching socket state 
+        switch( socket_state )
         {
-            match_socket = (local_addr  == seg_dst_addr) && 
-                           (local_port  == seg_dst_port) &&
-                           (remote_addr == seg_src_addr) &&
-                           (remote_port == seg_src_port) ;
-        }
-
-        // exit loop if matching
-        if( match_socket ) break;
-
-    }  // end loop on sockets
-
-    // release the lock protecting the list of sockets
-    remote_busylock_release( lock_xp );
-
-    // discard segment if no matching socket found
-    if( match_socket == false ) return;
-
-    // From here the actions depend on both the socket state,
-    // and the received segment flags
-    // - update socket state,
-    // - move data to rx_buf,
-    // - make a R2T request when required
-
-    // build extended pointers on various socket fields
-    socket_lock_xp    = XPTR( socket_cxy , &socket_ptr->lock );
-    socket_rx_buf_xp  = XPTR( socket_cxy , &socket_ptr->rx_buf );
-    socket_r2tq_xp    = XPTR( socket_cxy , &socket_ptr->r2tq );
-    socket_client_xp  = XPTR( socket_cxy , &socket_ptr->rx_client );
-
-    // 3. take the lock protecting the matching socket
-    remote_rwlock_wr_acquire( socket_lock_xp );
-
-    // get relevant socket infos from socket descriptor
-    socket_state   = hal_remote_l32(XPTR( socket_cxy , &socket_ptr->state ));
-    socket_rx_nxt = hal_remote_l32(XPTR( socket_cxy , &socket_ptr->rx_nxt )); 
-    socket_rx_wnd = hal_remote_l32(XPTR( socket_cxy , &socket_ptr->rx_wnd )); 
-    socket_tx_una = hal_remote_l32(XPTR( socket_cxy , &socket_ptr->tx_una )); 
-    socket_tx_nxt = hal_remote_l32(XPTR( socket_cxy , &socket_ptr->tx_nxt )); 
-
-    switch( socket_state )
-    {
-        //////////////////////
-        case TCP_STATE_LISTEN:
-        {
-            // [1] discard segment if RST flag
-            if( seg_rst_set )  return;
-
-            // [2] send a RST & discard segment if ACK flag
-            if( seg_ack_set )
+            ////////////////////////
+            case TCP_STATE_SYN_SENT:  // TCP client waiting for SYN-ACK in connect handshake
             {
-                    // set socket.tx_nxt to seg_ack_num
-                    hal_remote_s32( XPTR( socket_cxy , &socket_ptr->tx_nxt ),
-                                    seg_ack_num );
-
-                    // make RST request to R2T queue
-                    dev_nic_rx_put_r2t_request( socket_r2tq_xp,
-                                                TCP_FLAG_RST );
-                    // discard segment
+                // [1] check ACK flag 
+                if( seg_ack_set )
+                {
+                    if( seg_ack_num != TCP_ISS_CLIENT + 1 )  // bad ACK => report error
+                    {
+
+#if DEBUG_DEV_NIC_RX
+printk("\n[%s] thread[%x,%x] socket[%x,%d] %s : expect ack_num %x / get %x\n",
+__FUNCTION__, this->process->pid, this->trdid, pid, fdid,
+socket_state_str(socket_state), TCP_ISS_CLIENT + 1, seg_ack_num );
+#endif
+                        // make an RST request to R2T queue
+                        socket_put_r2t_request( socket_r2tq_xp,
+                                                TCP_FLAG_RST,
+                                                chdev->channel );
+
+                        // report error to local TX client thread
+                        dev_nic_unblock_tx_client( socket_xp , CMD_STS_BADACK );
+
+                        break;
+                    }
+                }
+
+                // [2] check RST flag                       // receive RST => report error
+                if( seg_rst_set )
+                {
+
+#if DEBUG_DEV_NIC_RX
+printk("\n[%s] thread[%x,%x] socket[%x,%d] %s : received RST flag\n",
+__FUNCTION__, this->process->pid, this->trdid, pid, fdid, socket_state_str(socket_state) );
+#endif
+                    // update socket state
+                    hal_remote_s32( XPTR( socket_cxy , &socket_ptr->state ),
+                                          TCP_STATE_BOUND );
+
+                    // signal error to local TX client thread
+                    dev_nic_unblock_tx_client( socket_xp , CMD_STS_RST );
+
                     break;
                 }
 
-                // [3] handle SYN flag
-                if( seg_syn_set )
-                {
+                // [3] handle security & precedence TODO ... someday
+
+                // [4] handle SYN-ACK
+                if( seg_syn_set && seg_ack_set )  // received SYN and ACK => report success
+                { 
+
+#if DEBUG_DEV_NIC_RX
+printk("\n[%s] thread[%x,%x] socket[%x,%d] %s : received expected SYN-ACK\n",
+__FUNCTION__, this->process->pid, this->trdid, pid, fdid , socket_state_str(socket_state) );
+#endif
+                    // set socket.tx_una  
+                    hal_remote_s32( XPTR(socket_cxy , &socket_ptr->tx_una), seg_ack_num );
+
+                    // set socket.rx_irs
+                    hal_remote_s32( XPTR(socket_cxy , &socket_ptr->rx_irs), seg_seq_num );
+
+                    // set socket.rx_nxt
+                    hal_remote_s32( XPTR(socket_cxy , &socket_ptr->rx_nxt), seg_seq_num + 1 );
+
+                    // update socket.state
+                    hal_remote_s32( XPTR(socket_cxy , &socket_ptr->state), TCP_STATE_ESTAB );
+
+                    // make an ACK request to R2T queue
+                    socket_put_r2t_request( socket_r2tq_xp,
+                                            TCP_FLAG_ACK,
+                                            chdev->channel );
+
+                    // report succes to local TX client thread
+                    dev_nic_unblock_tx_client( socket_xp , CMD_STS_SUCCESS );
+                }
+                else        // received SYN without ACK => client becomes server
+                {
+
+#if DEBUG_DEV_NIC_RX
+printk("\n[%s] thread[%x,%x] for socket[%x,%d] %s : received SYN-ACK => become server\n",
+__FUNCTION__, this->process->pid, this->trdid, pid, fdid , socket_state_str(socket_state) );
+#endif
+                    // update socket.state
+                    hal_remote_s32( XPTR(socket_cxy,&socket_ptr->state), TCP_STATE_SYN_RCVD );
+
+                    // set socket.tx_nxt 
+                    hal_remote_s32( XPTR(socket_cxy , &socket_ptr->tx_nxt), TCP_ISS_SERVER );
+
                     // set socket.rx_nxt to seg_seq_num + 1
-                    hal_remote_s32( XPTR( socket_cxy , &socket_ptr->rx_nxt ),
-                                    seg_seq_num + 1 );
-
-                    // set socket.tx_nxt to ISS
-                    hal_remote_s32( XPTR( socket_cxy , &socket_ptr->tx_nxt ),
-                                    TCP_ISS );
-
-                    // set socket.rx_irs to seg_seq_num 
-                    hal_remote_s32( XPTR( socket_cxy , &socket_ptr->rx_irs ),
-                                    seg_seq_num + 1 );
-
-                    // make SYN.ACK request to R2T queue
-                    dev_nic_rx_put_r2t_request( socket_r2tq_xp,
-                                                TCP_FLAG_SYN | TCP_FLAG_ACK );
-                     
-                    // set socket.tx_nxt to ISS + 1
-                    hal_remote_s32( XPTR( socket_cxy , &socket_ptr->tx_nxt ),
-                                    TCP_ISS + 1 );
-
-                    // set socket.tx_una to ISS
-                    hal_remote_s32( XPTR( socket_cxy , &socket_ptr->tx_una ),
-                                    TCP_ISS ); 
-            
-                    // update socket.state
-                    hal_remote_s32( XPTR( socket_cxy , &socket_ptr->state ),
-                                    TCP_STATE_SYN_RCVD );
-
-                    // update socket.remote_addr 
-                    hal_remote_s32( XPTR( socket_cxy , &socket_ptr->remote_addr ),
-                                    seg_src_addr );
-
-                    // update socket.remote_port 
-                    hal_remote_s32( XPTR( socket_cxy , &socket_ptr->remote_port ),
-                                    seg_src_port );
-                }                
+                    hal_remote_s32( XPTR(socket_cxy,&socket_ptr->rx_nxt), seg_seq_num + 1 );
+
+                    // make a SYN.ACK request to R2T queue
+                    socket_put_r2t_request( socket_r2tq_xp,
+                                            TCP_FLAG_SYN | TCP_FLAG_ACK,
+                                            chdev->channel );
+                }
                 break;
             }
             ////////////////////////
-            case TCP_STATE_SYN_SENT:
+            case TCP_STATE_SYN_RCVD:  // TCP server waiting last ACK in connect handshake 
             {
-                // [1] check ACK flag 
-                if( seg_ack_set )
-                {
-                    if( seg_ack_num != TCP_ISS + 1 )  // ACK not acceptable
-                    {
-                        // discard segment if RST
-                        if( seg_rst_set ) break;
-
-                        // set socket.tx_nxt to seg_ack_num
-                        hal_remote_s32( XPTR( socket_cxy , &socket_ptr->tx_nxt ),
-                                        seg_ack_num );
-
-                        // make an RST request to R2T queue
-                        dev_nic_rx_put_r2t_request( socket_r2tq_xp,
-                                                    TCP_FLAG_RST );
-                        // discard segment
-                        break;
-                    }
-                }
-
-                // [2] check RST flag
+                // [1] check sequence number
+                if( seg_seq_num != socket_rx_nxt )        // unexpected SEQ_NUM => discard
+                {
+
+#if DEBUG_DEV_NIC_RX
+printk("\n[%s] thread[%x,%x] socket[%x,%d] %s : expect seq_num %x / get %x\n",
+__FUNCTION__, this->process->pid, this->trdid, pid, fdid,
+socket_state_str(socket_state), socket_rx_nxt, seg_seq_num );
+#endif
+                    // discard segment without reporting
+                    break;
+                } 
+
+                // [2] handle RST flag                    // received RST => report error
                 if( seg_rst_set )
                 {
-                    // TODO signal "error: connection reset" to user
+
+#if DEBUG_DEV_NIC_RX
+printk("\n[%s] thread[%x,%x] socket[%x,%d] %s : received RST flag\n",
+__FUNCTION__, this->process->pid, this->trdid, pid, fdid , socket_state_str(socket_state) );
+#endif
+                    // update socket state
+                    hal_remote_s32( XPTR( socket_cxy , &socket_ptr->state ), TCP_STATE_BOUND );
+
+                    // report error to local TX client thread
+                    dev_nic_unblock_tx_client( socket_xp , CMD_STS_RST );
+
+                    break;
+                }
+
+                // [3] handle security & precedence TODO ... someday
+
+                // [4] handle SYN flag 
+                if( seg_syn_set )                           // received SYN => discard
+                {
+
+#if DEBUG_DEV_NIC_RX
+printk("\n[%s] thread[%x,%x] socket[%x,%d] %s : received SYN flag\n",
+__FUNCTION__, this->process->pid, this->trdid, pid, fdid , socket_state_str(socket_state) );
+#endif
+                    // discard segment without reporting
+                    break;
+                } 
+
+                // [5] handle  ACK flag 
+                if( seg_ack_set == false )                      // missing ACK => discard
+                {
+
+#if DEBUG_DEV_NIC_RX
+printk("\n[%s] thread[%x,%x] socket[%x,%d] %s : no ACK in TCP segment\n",
+__FUNCTION__, this->process->pid, this->trdid, pid, fdid , socket_state_str(socket_state) );
+#endif
+                    // discard segment without reporting
+                    break;
+                }
+                else if( seg_ack_num != (TCP_ISS_SERVER + 1) )  // unacceptable ACK
+                {
+
+#if DEBUG_DEV_NIC_RX
+printk("\n[%s] thread[%x,%x] socket[%x,%d] %s : expect ack_num %x / get %x\n",
+__FUNCTION__, this->process->pid, this->trdid, pid, fdid, 
+socket_state_str(socket_state), TCP_ISS_SERVER + 1, seg_ack_num );
+#endif
+
+                    // register an RST request to R2TQ for remote TCP client 
+                    socket_put_r2t_request( socket_r2tq_xp,
+                                            TCP_FLAG_RST,
+                                            chdev->channel );
+
+                    // report error to local TX client thread
+                    dev_nic_unblock_tx_client( socket_xp , CMD_STS_BADACK );
+                }
+                else                                           // acceptable ACK
+                {
+
+#if DEBUG_DEV_NIC_RX
+printk("\n[%s] thread[%x,%x] socket[%x,%d] %s : received expected ACK\n",
+__FUNCTION__, this->process->pid, this->trdid, pid, fdid , socket_state_str(socket_state) );
+#endif
+                    // set socket.tx_una  
+                    hal_remote_s32( XPTR(socket_cxy , &socket_ptr->tx_una), seg_ack_num );
 
                     // update socket.state
-                    hal_remote_s32( XPTR( socket_cxy , &socket_ptr->state ),
-                                    TCP_STATE_BOUND );
-
-                    // discard segment
-                    break;
-                }
-
-                // [3] handle SYN flag when (no ACK or acceptable ACK, and no RST)
-                if( seg_syn_set )
-                {
-                    // TODO Ne faut-il pas tester seg_seq_num ?
-
-                    if( seg_ack_set )  // received both SYN and ACK
-                    { 
-                        // set socket.rx_nxt to seg_seq_num + 1 
-                        hal_remote_s32( XPTR( socket_cxy , &socket_ptr->rx_nxt ),
-                                        seg_seq_num + 1 );
-
-                        // set socket.tx_una to seg_ack_num 
-                        hal_remote_s32( XPTR( socket_cxy , &socket_ptr->tx_una ),
-                                        seg_ack_num );
-
-                        // set socket.rx_irs to seg_seq_num
-                        hal_remote_s32( XPTR( socket_cxy , &socket_ptr->rx_irs ),
-                                        seg_seq_num );
-
-                        // update socket.state
-                        hal_remote_s32( XPTR( socket_cxy , &socket_ptr->state ),
-                                        TCP_STATE_ESTAB );
-
-                        // make an ACK request to R2T queue
-                        dev_nic_rx_put_r2t_request( socket_r2tq_xp,
-                                                    TCP_FLAG_ACK );
-                    }
-                    else               // received SYN without ACK
-                    {
-                        // update socket.state
-                        hal_remote_s32( XPTR( socket_cxy , &socket_ptr->state ),
-                                        TCP_STATE_SYN_RCVD );
-
-                        // set socket.tx_nxt to ISS
-                        hal_remote_s32( XPTR( socket_cxy , &socket_ptr->tx_nxt ),
-                                        TCP_ISS );     
-
-                        // make a SYN.ACK request to R2T queue
-                        dev_nic_rx_put_r2t_request( socket_r2tq_xp,
-                                                    TCP_FLAG_SYN | TCP_FLAG_ACK );
-                    }
+                    hal_remote_s32( XPTR(socket_cxy , &socket_ptr->state), 
+                                    TCP_STATE_ESTAB );
+
+                    // report success to local TX client thread
+                    dev_nic_unblock_tx_client( socket_xp , CMD_STS_SUCCESS );
                 }
                 break;
             }
-            ////////////////////////
-            case TCP_STATE_SYN_RCVD:
+            /////////////////////
             case TCP_STATE_ESTAB:
             case TCP_STATE_FIN_WAIT1:
@@ -1760 +1127 @@
             case TCP_STATE_TIME_WAIT:
             {
-                // [1] check sequence number 
-
-                // compute min & max acceptable sequence numbers
-                uint32_t seq_min  = socket_rx_nxt;
-                uint32_t seq_max  = socket_rx_nxt + socket_rx_wnd - 1;
-
-                // compute sequence number for last byte in segment 
-                uint32_t seg_seq_last = seg_seq_num + seg_payload - 1;
-
-                if( (seg_seq_num != socket_rx_nxt) ||     // out_of_order 
-                    (is_in_window( seg_seq_last, 
-                                   seq_min,
-                                   seq_max ) == false) )  // out_of_window
-                {
+                // [1] check sequence number : out_of_order segments not accepted
+                if( seg_seq_num != socket_rx_nxt )
+                {
+
+#if DEBUG_DEV_NIC_RX
+printk("\n[%s] thread[%x,%x] socket[%x,%d] %s : illegal SEQ_NUM %x / expected %x\n",
+__FUNCTION__, this->process->pid, this->trdid, pid, fdid,
+socket_state_str(socket_state), seg_seq_num, socket_rx_nxt );
+#endif
                     // discard segment
-                    return;
+                    break;
                 } 
 
-                // [2] handle RST flag
-
-                if( seg_rst_set )
-                {
-                     if( socket_state == TCP_STATE_SYN_RCVD )
-                     {
-                         // TODO unblock all clients threads with "reset" responses
-                     }
-                     else if( (socket_state == TCP_STATE_ESTAB     ) ||
-                              (socket_state == TCP_STATE_FIN_WAIT1 ) ||
-                              (socket_state == TCP_STATE_FIN_WAIT2 ) ||
-                              (socket_state == TCP_STATE_CLOSE_WAIT) )
-                     {
-                         // TODO all pending send & received commands 
-                         // must receive "reset" responses
-
-                         // TODO destroy the socket
-                     }
-                     else  // all other states
-                     {
-                             
-
-                }
-
-                // [3] handle security & precedence TODO ... someday
-
-                // [4] handle SYN flag
-
-                if( seg_syn_set )        // received SYN
-                {
-                    // TODO signal error to user
-
-                    // make an RST request to R2T queue 
-                    dev_nic_rx_put_r2t_request( socket_r2tq_xp,
-                                                TCP_FLAG_RST );
-                    // update socket state
-                    hal_remote_s32( XPTR( socket_cxy , &socket_ptr->state ),
-                                    TCP_STATE_BOUND );
-                }
-
-                // [5] handle  ACK flag 
-
-                if( seg_ack_set == false ) 
-                {
-                    // discard segment when ACK not set
-                    break;
-                }
-                else if( socket_state == TCP_STATE_SYN_RCVD )
-                {
-                    if( is_in_window( seg_ack_num , socket_tx_una , socket_tx_nxt ) ) 
+                // check all bytes in window when the payload exist
+                // TODO : we could accept bytes that are in window, 
+                // but this implementation reject all bytes in segment 
+                if( seg_data_len > 0 )
+                {
+                    // compute min & max acceptable sequence numbers
+                    uint32_t seq_min  = socket_rx_nxt;
+                    uint32_t seq_max  = socket_rx_nxt + socket_rx_wnd - 1;
+
+                    // compute sequence number for last byte in segment 
+                    uint32_t seg_seq_last = seg_seq_num + seg_data_len - 1;
+                      
+                    if( is_in_window( seg_seq_last, seq_min, seq_max ) == false ) 
                     {
-                        // update socket.state to ESTAB
-                        hal_remote_s32( XPTR( socket_cxy , &socket_ptr->state ),
-                                              TCP_STATE_ESTAB );
-                    }
-                    else   // unacceptable ACK
-                    {
-                        // set socket.tx_nxt to seg_ack_num 
-                        hal_remote_s32( XPTR( socket_cxy , &socket_ptr->rx_nxt ),
-                                        seg_ack_num );
-
-                        // make an RST request to R2T queue 
-                        dev_nic_rx_put_r2t_request( socket_r2tq_xp,
-                                                    TCP_FLAG_RST );
-                    }
-                }
-                else if( (socket_state == TCP_STATE_ESTAB)      ||
-                         (socket_state == TCP_STATE_FIN_WAIT1)  ||
-                         (socket_state == TCP_STATE_FIN_WAIT1)  ||
-                         (socket_state == TCP_STATE_CLOSE_WAIT) ||
-                         (socket_state == TCP_STATE_CLOSING)    )
-                {
-                    if( is_in_window( seg_ack_num + 1 , socket_tx_una , socket_tx_nxt ) ) 
-                    {
-                        // update socket.tx_una
-                        hal_remote_s32( XPTR( socket_cxy , &socket_ptr->tx_una ),
-                                        seg_ack_num );
-
-                        // update socket.tx_wnd  
-                        hal_remote_s32( XPTR( socket_cxy , &socket_ptr->tx_wnd ),
-                                        seg_window );
-                    }
-                    else   // unacceptable ACK
-                    {
+
+#if DEBUG_DEV_NIC_RX
+printk("\n[%s] thread[%x,%x] socket[%x,%d] %s : last SEQ_NUM %x not in [%x,%x]\n",
+__FUNCTION__, this->process->pid, this->trdid, pid, fdid,
+socket_state_str(socket_state), seg_seq_last, seq_min, seq_max );
+#endif
                         // discard segment
                         break;
                     }
-                
-                    // specific for FIN_WAIT1 
-                    if( socket_state == TCP_STATE_FIN_WAIT1 )
+                } 
+
+                // [2] handle RST flag
+                if( seg_rst_set )
+                {
+
+#if DEBUG_DEV_NIC_RX
+printk("\n[%s] thread[%x,%x] socket[%x,%d] %s : received RST flag\n",
+__FUNCTION__, this->process->pid, this->trdid, pid, fdid, socket_state_str(socket_state) );
+#endif
+                    if( (socket_state == TCP_STATE_ESTAB     ) ||
+                        (socket_state == TCP_STATE_FIN_WAIT1 ) ||
+                        (socket_state == TCP_STATE_FIN_WAIT2 ) ||
+                        (socket_state == TCP_STATE_CLOSE_WAIT) )
                     {
-                        if( seg_fin_set )
-                        {
-                            // update socket.state
-                            hal_remote_s32( XPTR( socket_cxy , &socket_ptr->state ),
-                                                  TCP_STATE_FIN_WAIT2 );
-                        }
+                        // TODO all pending send & received commands 
+                        // must receive "reset" responses
+
+                        // TODO destroy the socket
                     }
-
-                    // specific for CLOSING
-                    if( socket_state == TCP_STATE_CLOSING )
+                    else  // states CLOSING / LAST_ACK / TIME_WAIT
                     {
-                        if( seg_ack_set )
-                        {
-                            // update socket.state
-                            hal_remote_s32( XPTR( socket_cxy , &socket_ptr->state ),
-                                                  TCP_STATE_TIME_WAIT );
-                        }
-                        else
-                        {
-                            // discard segment
-                            break;
-                        }
+                        // TODO          
                     }
-                }
-                else if( socket_state == TCP_STATE_LAST_ACK )
-                {
-                    if( seg_ack_set )
+                    break;
+                }
+
+                // [3] handle security & precedence TODO ... someday
+
+                // [4] check SYN flag 
+                if( seg_syn_set )                                // received SYN => ERROR
+                {
+
+#if DEBUG_DEV_NIC_RX
+printk("\n[%s] thread[%x,%x] socket[%x,%d] %s : received unexpected SYN\n",
+__FUNCTION__, this->process->pid, this->trdid, pid, fdid , socket_state_str(socket_state) );
+#endif
+                    // TODO signal error to user
+
+                    // make an RST request to R2T queue 
+                    socket_put_r2t_request( socket_r2tq_xp, 
+                                            TCP_FLAG_RST,
+                                            chdev->channel );
+
+                    // update socket state
+                    hal_remote_s32( XPTR(socket_cxy , &socket_ptr->state), TCP_STATE_BOUND );
+
+                    break;
+                }
+
+                // [5] check ACK  
+                if( seg_ack_set == false )                           // missing ACK
+                {
+
+#if DEBUG_DEV_NIC_RX
+printk("\n[%s] thread[%x,%x] socket[%x,%d] %s : no ACK flag\n",
+__FUNCTION__, this->process->pid, this->trdid, pid, fdid, socket_state_str(socket_state) );
+#endif
+                    // discard segment
+                    break;
+                }
+                else if( is_in_window( seg_ack_num,
+                                       socket_tx_una,
+                                       socket_tx_nxt ) == false )    // unacceptable ACK
+                {
+
+#if DEBUG_DEV_NIC_RX
+printk("\n[%s] thread[%x,%x] socket[%x,%d] %s : ACK_NUM %x not in [%x,%x]\n",
+__FUNCTION__, this->process->pid, this->trdid, pid, fdid, socket_state_str(socket_state),
+seg_ack_num, socket_tx_una, socket_tx_nxt );
+#endif
+                    // discard segment
+                    break;
+                }
+                else                                                // acceptable ack
+                {
+                    // update socket.tx_una
+                    hal_remote_s32( XPTR(socket_cxy , &socket_ptr->tx_una), seg_ack_num );
+
+                    // update socket.tx_wnd  
+                    hal_remote_s32( XPTR(socket_cxy , &socket_ptr->tx_wnd), seg_window );
+
+                    // check last data byte acknowledged for a SEND command
+                    if( (socket_tx_todo == 0) && 
+                        (seg_ack_num == socket_tx_nxt) &&
+                        (socket_tx_cmd == CMD_TX_SEND) )
                     {
-                        // update socket.state
-                        hal_remote_s32( XPTR( socket_cxy , &socket_ptr->state ),
-                                              TCP_STATE_TIME_WAIT );
+                        // signal success to TX client thread
+                        dev_nic_unblock_tx_client( socket_xp , CMD_STS_SUCCESS );
                     }
+                }
                     
-                }
-
-                // [6] handle URG flag  TODO ... someday
-
-                // [7] Move DATA to rx_buf and unblock client thread
-
-                if( seg_payload )
+                // [7] handle URG flag  TODO ... someday
+
+                // [8] Move DATA to rx_buf / ACK request to R2T queue / unblock rx_client
+                if( seg_data_len )
                 {
                     if( (socket_state == TCP_STATE_ESTAB)     ||
@@ -1920 +1270 @@
                         uint32_t space = NIC_RX_BUF_SIZE - status;
 
-                        // compute number of bytes to move : min (space , seg_payload)
-                        uint32_t nbytes = ( space < seg_payload ) ? space : seg_payload;
+                        // compute number of bytes to move : min (space , seg_data_len)
+                        uint32_t nbytes = ( space < seg_data_len ) ? space : seg_data_len;
 
                         // move payload from k_buf to rx_buf
@@ -1927 +1277 @@
                                                     k_buf + seg_hlen,
                                                     nbytes );
+#if DEBUG_DEV_NIC_RX
+printk("\n[%s] thread[%x,%x] socket[%x,%d] %s : move %d bytes to rx_buf\n",
+__FUNCTION__, this->process->pid, this->trdid, pid, fdid,
+socket_state_str(socket_state), nbytes );
+#endif
                         // update socket.rx_nxt 
                         hal_remote_s32( XPTR( socket_cxy , &socket_ptr->rx_nxt ),
@@ -1933 +1288 @@
                         // update socket.rx_wnd 
                         hal_remote_s32( XPTR( socket_cxy , &socket_ptr->rx_wnd ),
-                                        socket_rx_wnd - nbytes ); 
-
-                        // make an ACK request to R2T queue
-                        dev_nic_rx_put_r2t_request( socket_r2tq_xp,
-                                                    TCP_FLAG_ACK );
-
-                        // get extended pointer on rx_client thread
-                        xptr_t client_xp = hal_remote_l64( socket_client_xp );
-                        
-                        // unblock client thread 
-                        if( client_xp != XPTR_NULL )
+                                              socket_rx_wnd - nbytes ); 
+
+                        // make an ACK request to R2T queue 
+                        socket_put_r2t_request( socket_r2tq_xp,
+                                                TCP_FLAG_ACK,
+                                                chdev->channel );
+
+                        // check pending RX_RECV command
+                        if( (socket_rx_valid == true) &&
+                            (socket_rx_cmd == CMD_RX_RECV) )
                         {
-                            thread_unblock( client_xp , THREAD_BLOCKED_IO );
+                            // reset rx_valid
+                            hal_remote_s32( XPTR(socket_cxy,&socket_ptr->rx_valid), false );
+
+                            // report success to RX client thread
+                            dev_nic_unblock_rx_client( socket_xp , CMD_STS_SUCCESS );
+#if DEBUG_DEV_NIC_RX
+printk("\n[%s] thread[%x,%x] socket[%x,%d] %s : unblock waiting RX client thread\n",
+__FUNCTION__, this->process->pid, this->trdid, pid, fdid,
+socket_state_str(socket_state) );
+#endif
                         }
                     }
                 }
 
-                // [8] handle FIN flag 
-
-                if( seg_fin_set )
-                {
-                    if( (socket_state == TCP_STATE_UNBOUND) ||
-                        (socket_state == TCP_STATE_BOUND)   ||
-                        (socket_state == TCP_STATE_LISTEN)  ||
-                        (socket_state == TCP_STATE_SYN_SENT) ) 
+                // [9] handle FIN flag 
+                if( socket_state == TCP_STATE_ESTAB )
+                {
+                    if( seg_fin_set )  // received ACK & FIN    
                     {
-                        // discard segment
-                        break;
-                    }
-                    else // all other states
-                    {
-                        // TODO signal "connection closing"
-
-                        // make an ACK request to R2T queue
-                        dev_nic_rx_put_r2t_request( socket_r2tq_xp,
-                                                    TCP_FLAG_ACK );
-
-                        // increment socket.rx_nxt
+
+#if DEBUG_DEV_NIC_RX
+printk("\n[%s] thread[%x,%x] socket[%x,%d] %s : FIN-ACK => goes CLOSE_WAIT\n",
+__FUNCTION__, this->process->pid, this->trdid, pid, fdid,
+socket_state_str(socket_state) );
+#endif
+                        // update socket.rx_nxt when FIN received
                         hal_remote_s32( XPTR( socket_cxy , &socket_ptr->rx_nxt ),
                                         socket_rx_nxt + 1 ); 
 
-                        if( (socket_state == TCP_STATE_SYN_RCVD) ||
-                            (socket_state == TCP_STATE_ESTAB) )
+                        // update socket state
+                        hal_remote_s32( XPTR( socket_cxy , &socket_ptr->state ),
+                                        TCP_STATE_CLOSE_WAIT );
+
+                        // make an ACK request to R2T queue
+                        socket_put_r2t_request( socket_r2tq_xp,
+                                                TCP_FLAG_ACK,
+                                                chdev->channel );
+
+                        // check pending RX_RECV command
+                        if( (socket_rx_valid == true) &&
+                            (socket_rx_cmd == CMD_RX_RECV) )
                         {
-                            // update socket.state
-                            hal_remote_s32( XPTR( socket_cxy , &socket_ptr->state ),
-                                            TCP_STATE_TIME_WAIT );
-                        }
-                        else if( socket_state == TCP_STATE_FIN_WAIT1 )
-                        { 
-                            if( seg_ack_set ) 
-                            {
-                                // TODO start "time-wait" timer / turn off others timers
-
-                                // update socket.state
-                                hal_remote_s32( XPTR( socket_cxy , &socket_ptr->state ),
-                                                TCP_STATE_TIME_WAIT );
-                            }
-                            else
-                            {
-                                // update socket.state
-                                hal_remote_s32( XPTR( socket_cxy , &socket_ptr->state ),
-                                                TCP_STATE_CLOSING );
-                            }
-                        }
-                        else if( socket_state == TCP_STATE_FIN_WAIT2 )
-                        {
-                            // TODO start "time-wait" timer / turn off other timers
-
-                            // update socket.state
-                            hal_remote_s32( XPTR( socket_cxy , &socket_ptr->state ),
-                                            TCP_STATE_TIME_WAIT );
-                        }
-                        else if( socket_state == TCP_STATE_TIME_WAIT )
-                        {
-                            // TODO restart "time_wait" timer
-                        }
+                            // reset rx_valid
+                            hal_remote_s32( XPTR(socket_cxy,&socket_ptr->rx_valid), false );
+
+                            // report error to RX client thread
+                            dev_nic_unblock_rx_client( socket_xp , CMD_STS_EOF );
+#if DEBUG_DEV_NIC_RX
+printk("\n[%s] thread[%x,%x] socket[%x,%d] %s : unblock RX client waiting on RECV\n",
+__FUNCTION__, this->process->pid, this->trdid, pid, fdid,
+socket_state_str(socket_state) );
+#endif
+                        } 
                     }
-                }  // end if FIN 
-            }  // end case sockets synchronized
+                }
+                else if( socket_state == TCP_STATE_FIN_WAIT1 )
+                {
+                    if( seg_fin_set )  // received ACK & FIN
+                    { 
+
+#if DEBUG_DEV_NIC_RX
+printk("\n[%s] thread[%x,%x] socket[%x,%d] %s : FIN-ACK => goes CLOSING\n",
+__FUNCTION__, this->process->pid, this->trdid, pid, fdid,
+socket_state_str(socket_state) );
+#endif
+                        // update socket.rx_nxt when FIN received
+                        hal_remote_s32( XPTR( socket_cxy , &socket_ptr->rx_nxt ),
+                                        socket_rx_nxt + 1 ); 
+
+                        // update socket state
+                        hal_remote_s32( XPTR( socket_cxy , &socket_ptr->state ),
+                                        TCP_STATE_CLOSING );
+
+                        // make an ACK request to R2T queue
+                        socket_put_r2t_request( socket_r2tq_xp,
+                                                TCP_FLAG_ACK,
+                                                chdev->channel );
+                    }
+                    else              // received ACK only 
+                    {
+
+#if DEBUG_DEV_NIC_RX
+printk("\n[%s] thread[%x,%x] socket[%x,%d] %s : only ACK => goes FIN_WAIT2\n",
+__FUNCTION__, this->process->pid, this->trdid, pid, fdid,
+socket_state_str(socket_state) );
+#endif
+                        // update socket state
+                        hal_remote_s32( XPTR( socket_cxy , &socket_ptr->state ),
+                                        TCP_STATE_FIN_WAIT2 );
+                    }
+                }
+                else if( socket_state == TCP_STATE_FIN_WAIT2 )
+                {
+                    if( seg_fin_set )  // received ACK & FIN
+                    { 
+
+#if DEBUG_DEV_NIC_RX
+printk("\n[%s] thread[%x,%x] socket[%x,%d] %s : FIN-ACK => goes CLOSED / unblock client\n",
+__FUNCTION__, this->process->pid, this->trdid, pid, fdid,
+socket_state_str(socket_state) );
+#endif
+                        // update socket.rx_nxt when FIN received
+                        hal_remote_s32( XPTR( socket_cxy , &socket_ptr->rx_nxt ),
+                                        socket_rx_nxt + 1 ); 
+
+                        // update socket.state 
+                        hal_remote_s32( XPTR( socket_cxy , &socket_ptr->state ),
+                                        TCP_STATE_CLOSED );  // TODO change to TIME_WAIT
+
+                        // make an ACK request to R2T queue
+                        socket_put_r2t_request( socket_r2tq_xp,
+                                                TCP_FLAG_ACK,
+                                                chdev->channel );
+                
+                        // report success to TX client thread
+                        dev_nic_unblock_tx_client( socket_xp , CMD_STS_SUCCESS );
+
+                        // TODO start the MSL timer / turn off others timers
+
+                    }
+                }
+                else if( socket_state == TCP_STATE_CLOSING )   // received ACK
+                {
+                    // update socket.state
+                    hal_remote_s32( XPTR( socket_cxy , &socket_ptr->state ),
+                                    TCP_STATE_CLOSED );  // todo change to TIME_WAIT
+
+                    // TODO start the MSL timer / turn off others timers
+
+                }
+                else if( socket_state == TCP_STATE_TIME_WAIT )
+                {
+                    // TODO wait msl_time_out before unblocking TX thread
+
+                    // update socket.state when ACK received
+                    hal_remote_s32( XPTR( socket_cxy , &socket_ptr->state ),
+                                    TCP_STATE_CLOSED );
+
+                    // unblock TX client thead for success
+                    dev_nic_unblock_tx_client( socket_xp , CMD_STS_SUCCESS );
+                }
+                else if( socket_state == TCP_STATE_CLOSE_WAIT )
+                {
+                    // do nothing 
+                }
+                else if( socket_state == TCP_STATE_LAST_ACK )
+                {
+                    // update socket.state when ACK received
+                    hal_remote_s32( XPTR( socket_cxy , &socket_ptr->state ),
+                                    TCP_STATE_CLOSED );
+
+                    // unblock TX client thead for success
+                    dev_nic_unblock_tx_client( socket_xp , CMD_STS_SUCCESS );
+                }
+            }  // end case connecteded states
         }  // end switch socket state
 
-        // release the lock protecting socket
-        remote_rwlock_wr_acquire( socket_lock_xp );
-
-    }  // end socket found
+        // release the lock protecting socket state
+        remote_queuelock_release( socket_lock_xp );
+
+        return;
+
+    }  // end if attached socket
+
+    // 4. scan the list of listening sockets
+    listening_match = false;
+ 
+    // get pointers on NIC_RX[0] chdev
+    xptr_t    rx0_chdev_xp  = chdev_dir.nic_rx[0];
+    chdev_t * rx0_chdev_ptr = GET_PTR( rx0_chdev_xp );
+    cxy_t     rx0_chdev_cxy = GET_CXY( rx0_chdev_xp );
+   
+    // build extended pointers on list of listening sockets
+    xptr_t    rx0_root_xp = XPTR( rx0_chdev_cxy , &rx0_chdev_ptr->ext.nic.root );
+    xptr_t    rx0_lock_xp = XPTR( rx0_chdev_cxy , &rx0_chdev_ptr->ext.nic.lock );
+
+    // take the lock protecting the list of listening sockets
+    remote_busylock_acquire( rx0_lock_xp );
+
+    // scan the xlist of listening socket
+    XLIST_FOREACH( rx0_root_xp , iter_xp )
+    {
+        // get socket cluster and local pointer
+        socket_xp  = XLIST_ELEMENT( iter_xp , socket_t , rx_list );
+        socket_ptr = GET_PTR( socket_xp );
+        socket_cxy = GET_CXY( socket_xp );
+
+        // get relevant socket type and state
+        socket_type     = hal_remote_l32(XPTR(socket_cxy , &socket_ptr->type ));
+        socket_state    = hal_remote_l32(XPTR(socket_cxy , &socket_ptr->state ));
+                
+// check socket type and state
+assert( (socket_type  == SOCK_STREAM ) , "illegal socket type" );
+assert( (socket_state == TCP_STATE_LISTEN ) , "illegal socket state" );
+
+        // get relevant socket infos for matching
+        socket_local_addr   = hal_remote_l32(XPTR(socket_cxy , &socket_ptr->local_addr )); 
+        socket_local_port   = hal_remote_l32(XPTR(socket_cxy , &socket_ptr->local_port )); 
+                
+        // compute matching condition for a listening socket
+        listening_match = (socket_local_addr  == seg_local_addr) && 
+                          (socket_local_port  == seg_local_port);
+
+        // exit loop if matching
+        if( listening_match ) 
+        {
+
+#if DEBUG_DEV_NIC_RX
+fdid = hal_remote_l32( XPTR( socket_cxy , &socket_ptr->fdid ) );
+pid  = hal_remote_l32( XPTR( socket_cxy , &socket_ptr->pid ) );
+if( cycle > DEBUG_DEV_NIC_RX )
+printk("\n[%s] thread[%x,%x] matching listening socket[%d,%d] / state %s\n",
+__FUNCTION__, this->process->pid, this->trdid, pid, fdid, socket_state_str(socket_state) );
+#endif
+            break;
+        }
+    }   // end loop on listening sockets
+
+    // release the lock protecting the list of listening sockets
+    remote_busylock_release( rx0_lock_xp );
+
+    // 5. handle TCP segment for a matching listening socket
+    if( listening_match )
+    {
+        // The actions depend on the received segment flags
+        // - discard segment for RST or ACK
+        // - update socket state & remote IP address, 
+        //   register connect request in socket CRQ queue,
+        //   and unblock client thread for SYN 
+ 
+        // discard segment if RST flag
+        if( seg_rst_set )
+        {
+
+#if DEBUG_DEV_NIC_RX
+if( cycle > DEBUG_DEV_NIC_RX )
+printk("\n[%s] thread[%x,%x] for listening socket[%x,%d] : received RST\n",
+__FUNCTION__, this->process->pid, this->trdid, pid, fdid );
+#endif
+            return;
+        }
+
+        // discard segment if ACK flag
+        if( seg_ack_set ) 
+        {
+
+#if DEBUG_DEV_NIC_RX
+if( cycle > DEBUG_DEV_NIC_RX )
+printk("\n[%s] thread[%x,%x] for listening socket[%x,%d] : received ACK\n",
+__FUNCTION__, this->process->pid, this->trdid, pid, fdid );
+#endif
+            return;
+        }
+
+        // SYN flag == CONNECT request / seq_num cannot be wrong
+        if( seg_syn_set )
+        {
+            // build extended pointer on listening socket CRQ
+            socket_crqq_xp = XPTR( socket_cxy , &socket_ptr->crqq );
+
+            // try to register request into CRQ queue
+            error = socket_put_crq_request( socket_crqq_xp,
+                                            seg_remote_addr, 
+                                            seg_remote_port,
+                                            seg_seq_num,
+                                            seg_window );
+
+            if ( error )   // CRQ full
+            {
+
+#if DEBUG_DEV_NIC_RX
+if( cycle > DEBUG_DEV_NIC_RX )
+printk("\n[%s] thread[%x,%x] listening socket[%x,%d] CRQ full => send RST\n",
+__FUNCTION__, this->process->pid, this->trdid, pid, fdid );
+#endif
+                // make an RST request to R2T queue 
+                socket_put_r2t_request( socket_r2tq_xp,
+                                        TCP_FLAG_RST,
+                                        chdev->channel );
+            }
+            else          // new connection request registered in CRQ
+            {
+
+#if DEBUG_DEV_NIC_RX
+if( cycle > DEBUG_DEV_NIC_RX )
+printk("\n[%s] thread[%x,%x] for listening socket[%x,%d] : register request in CRQ\n",
+__FUNCTION__, this->process->pid, this->trdid, pid, fdid );
+#endif
+                // check pending RX_ACCEPT command
+                if( (hal_remote_l32(XPTR(socket_cxy,&socket_ptr->rx_valid)) == true) &&
+                    (hal_remote_l32(XPTR(socket_cxy,&socket_ptr->rx_cmd)) == CMD_RX_ACCEPT) )
+                {
+                    // reset rx_valid
+                    hal_remote_s32( XPTR( socket_cxy , &socket_ptr->rx_valid ), false );
+                     
+                    // report success to RX client thread
+                    dev_nic_unblock_rx_client( socket_xp , CMD_STS_SUCCESS );
+
+#if DEBUG_DEV_NIC_RX
+if( cycle > DEBUG_DEV_NIC_RX )
+printk("\n[%s] thread[%x,%x] for listening socket[%x,%d] unblock RX client thread\n", 
+__FUNCTION__, this->process->pid, this->trdid, pid, fdid );
+#endif
+                }
+            }   // end register request in CRQ
+        }   // end if SYN
+        
+        return;
+
+    }  // end if listening_match
+
+    // 6. no socket found => discard segment
+
+#if DEBUG_DEV_NIC_RX
+if( cycle > DEBUG_DEV_NIC_RX )
+printk("\n[%s] thread[%x,%x] exit failure : no socket found => discard segment\n",
+__FUNCTION__, this->process->pid, this->trdid );
+#endif
 
 }  // end dev_nic_rx_handle_tcp_segment()
@@ -2027 +1625 @@
 {
     uint8_t       k_buf[2048];          // kernel buffer for one ETH/IP/UDP packet
-                                  
     uint32_t      pkt_src_addr;         // packet source IP address 
     uint32_t      pkt_dst_addr;         // packet destination IP address
@@ -2033 +1630 @@
     uint32_t      eth_length;           // size of Ethernet packet (bytes)
     uint32_t      ip_length;            // size of IP packet in bytes
-    uint32_t      nic_queue_readable;   // NIC_RX queue non empty when true
     error_t       error;
 
-    thread_t * this = CURRENT_THREAD;
+    thread_t    * this = CURRENT_THREAD;
+
+// check thread can yield
+thread_assert_can_yield( this , __FUNCTION__ );
 
 // check chdev direction and type
@@ -2042 +1641 @@
 "illegal chdev type or direction" );
 
-// check thread can yield
-assert( (this->busylocks == 0),
-"cannot yield : busylocks = %d\n", this->busylocks );
+#if DEBUG_DEV_NIC_RX
+uint32_t   cycle = (uint32_t)hal_get_cycles();
+if( cycle > DEBUG_DEV_NIC_RX )
+printk("\n[%s] thread[%x,%x] starts / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, cycle );
+#endif
+
+    // get extended pointers on server tread and chdev 
+    xptr_t     thread_xp = XPTR( local_cxy , this );
+    xptr_t     chdev_xp  = XPTR( local_cxy , chdev );
 
     while( 1 )
     {
-        // check NIC_RX_QUEUE readable
-        error = dev_nic_rx_queue_readable( chdev,
-                                           &nic_queue_readable );
-        if( error )
+        // call NIC driver to move one packet from NIC_RX queue to kernel buffer
+        this->nic_cmd.dev_xp  = chdev_xp;
+        this->nic_cmd.type    = NIC_CMD_READ;
+        this->nic_cmd.buffer  = k_buf;
+        chdev->cmd( XPTR( local_cxy , this ) );
+
+        // get packet length   
+        eth_length = this->nic_cmd.status;
+
+        // check success
+        if( eth_length == 0 )  // queue empty => block and deschedule 
         {
-            printk("\n[PANIC] in %s : cannot access NIC_TX[%d] queue\n",
-            __FUNCTION__, chdev->channel );
+
+#if DEBUG_DEV_NIC_RX
+cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_DEV_NIC_RX < cycle )
+printk("\n[%s] thread[%x,%x] NIC_RX_QUEUE empty => blocks on <ISR> / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, cycle );
+#endif
+            // enable NIC_RX IRQ 
+            dev_pic_enable_irq( this->core->lid , chdev_xp );
+
+            // block and deschedule
+            thread_block( thread_xp , THREAD_BLOCKED_ISR );
+            sched_yield("client blocked on NIC_TX queue full");
+
+            // disable NIC-RX IRQ 
+            dev_pic_disable_irq( this->core->lid , chdev_xp );
+
+#if DEBUG_DEV_NIC_RX
+cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_DEV_NIC_RX < cycle )
+printk("\n[%s] thread[%x,%x] resumes / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, cycle );
+#endif
+
         }
-    
-        if( nic_queue_readable ) // NIC_TX_QUEUE non empty
+        else                 // success => handle packet
         {
-            // moves one Ethernet packet to kernel buffer
-            error = dev_nic_rx_move_packet( chdev,
-                                            k_buf,
-                                            &eth_length );
-            if( error )
-            {
-                printk("\n[PANIC] in %s : cannot read the NIC_TX[%d] queue\n",
-                __FUNCTION__, chdev->channel );
-            }
+
+#if DEBUG_DEV_NIC_RX
+cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_DEV_NIC_RX < cycle )
+dev_nic_packet_display( false,               // is_tx
+                        this->process->pid,
+                        this->trdid,
+                        cycle,
+                        k_buf );
+#endif
 
             // analyse the ETH header
@@ -2074 +1709 @@
 
             // discard packet if error reported by Ethernet layer
-            if( error ) continue; 
-
+            if( error )
+            {
+
+#if DEBUG_DEV_NIC_RX
+cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_DEV_NIC_RX < cycle )
+printk("\n[%s] thread[%x,%x] discard ETH packet / cycle %d\n", 
+__FUNCTION__, this->process->pid, this->trdid, cycle );
+#endif
+                continue; 
+            }
+
+#if (DEBUG_DEV_NIC_RX & 1)
+cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_DEV_NIC_RX < cycle )
+printk("\n[%s] thread[%x,%x] successfully checked ETH packet / cycle %d\n", 
+__FUNCTION__, this->process->pid, this->trdid, cycle );
+#endif
             // analyse the IP header
             error = dev_nic_rx_check_ip( k_buf + ETH_HEAD_LEN,
@@ -2084 +1735 @@
 
             // discard packet if error reported by IP layer
-            if( error ) continue; 
+            if( error ) 
+            {
+
+#if DEBUG_DEV_NIC_RX
+cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_DEV_NIC_RX < cycle )
+printk("\n[%s] thread[%x,%x] discarded IP packet / cycle %d\n", 
+__FUNCTION__, this->process->pid, this->trdid, cycle );
+#endif
+                continue; 
+            }
+
+#if (DEBUG_DEV_NIC_RX & 1 )
+cycle = (uint32_t)hal_get_cycles();
+if( (DEBUG_DEV_NIC_RX < cycle) && (trsp_protocol == PROTOCOL_UDP) )
+printk("\n[%s] thread[%x,%x] successfully checked UDP packet / cycle %d\n", 
+__FUNCTION__, this->process->pid, this->trdid, cycle );
+if( (DEBUG_DEV_NIC_RX < cycle) && (trsp_protocol == PROTOCOL_TCP) )
+printk("\n[%s] thread[%x,%x] successfully checked TCP segment / cycle %d\n", 
+__FUNCTION__, this->process->pid, this->trdid, cycle );
+#endif
 
             // call relevant transport protocol
@@ -2103 +1774 @@
                                                pkt_dst_addr );
             }
+            else // discard packet if unsupported transport protocol
+            {
+ 
+#if DEBUG_DEV_NIC_RX
+cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_DEV_NIC_RX < cycle )
+printk("\n[%s] thread[%x,%x] discarded unsupported transport protocol %d\n", 
+__FUNCTION__, this->process->pid, this->trdid, trsp_protocol, cycle );
+#endif
+                continue;
+            }
         }
-        else     // block and deschedule if NIC_RX_QUEUE empty
-        {
-            thread_block( XPTR( local_cxy , this ) , THREAD_BLOCKED_ISR );
-            sched_yield( "waiting RX client" );
-        }
-
     } // end of while loop
-
 }  // end dev_nic_rx_server()
 
@@ -2117 +1792 @@
 
 
-
-
-
-
-
-
 ///////////////////////////////////////////////////////////////////////////////////////////
 //              Functions used by the NIC_TX server thread
 ///////////////////////////////////////////////////////////////////////////////////////////
 
-
-///////////////////////////////////////////////////////////////////////////////////////////
-// These static functions are called by the NIC_TX server thread to report the 
-// completion  (success or error) of a TX command.
-// - it print an error message in case of error.
-// - it updates the "tx_error"  field in socket descriptor.
-// - it unblocks the client thread.
-///////////////////////////////////////////////////////////////////////////////////////////
-// @ socket_xp    : [in] extended pointer on socket
-// @ cmd_type     : [in] SOCKET_TX_CONNECT / SOCKET_TX_SEND / SOCKET_TX_CLOSE
-// @ socket_state : [in] current socket state
-///////////////////////////////////////////////////////////////////////////////////////////
-static void dev_nic_tx_report_error( xptr_t    socket_xp,
-                                     uint32_t  cmd_type,
-                                     uint32_t  socket_state )
-{
-    printk("\n[ERROR] in %s : command %s in %s state\n",
-    __FUNCTION__, socket_cmd_str(cmd_type), socket_state_str(socket_state) );
-
-    // get socket thread cluster and local pointer
-    socket_t * socket_ptr = GET_PTR( socket_xp );
-    cxy_t      socket_cxy = GET_CXY( socket_xp );
-
-    // set tx_error field in socket descriptor
-    hal_remote_s32( XPTR( socket_cxy , &socket_ptr->tx_error ) , 1 );
-
-    // get extended point on client thread
-    xptr_t client_xp = hal_remote_l64( XPTR( socket_cxy , &socket_ptr->tx_client ));
-
-    // unblock the client thread
-    thread_unblock( client_xp , THREAD_BLOCKED_IO );
-}
-
-////////////////////////////////////////////////////////////
-static void dev_nic_tx_report_success( xptr_t    socket_xp )
-{
-    // get socket thread cluster and local pointer
-    socket_t * socket_ptr = GET_PTR( socket_xp );
-    cxy_t      socket_cxy = GET_CXY( socket_xp );
-
-    // set tx_error field in socket descriptor
-    hal_remote_s32( XPTR( socket_cxy , &socket_ptr->tx_error ) , 0 );
-
-    // get extended point on client thread
-    xptr_t client_xp = hal_remote_l64( XPTR( socket_cxy , &socket_ptr->tx_client ));
-
-    // unblock the client thread
-    thread_unblock( client_xp , THREAD_BLOCKED_IO );
-}
-
-
-
-
-
-///////////////////////////////////////////////////////////////////////////////////////////
-// This static function is called by the dev_nic_tx_server() function.
-// It calls directly the NIC driver (WRITABLE command) and returns the status
-// of the NIC_TX queue identified by the <chdev> argument.
-// in the <writable> buffer.
-///////////////////////////////////////////////////////////////////////////////////////////
-// @ chdev     : [in]  local pointer on NIC_TX chdev.
-// @ length    : [in]  packet length in bytes.
-// @ writable  : [out] zero if queue full.  
-// @ returns 0 if success / returns -1 if failure in accessing NIC device.
-///////////////////////////////////////////////////////////////////////////////////////////
-error_t dev_nic_tx_queue_writable( chdev_t  * chdev,
-                                   uint32_t   length,
-                                   uint32_t * writable )
-{
-    thread_t * this = CURRENT_THREAD;
-
-    // initialize READABLE command in thread descriptor
-    this->nic_cmd.dev_xp = XPTR( local_cxy , chdev );
-    this->nic_cmd.type   = NIC_CMD_WRITABLE;
-    this->nic_cmd.length = length;
-
-    // call driver to test writable
-    chdev->cmd( XPTR( local_cxy , this ) );
-
-    // return status
-    *writable = this->nic_cmd.status;
-
-    // return error
-    return this->nic_cmd.error;
-
-}  // end dev_nic_tx_queue_writable
-
-///////////////////////////////////////////////////////////////////////////////////////////
-// This static function is called by the dev_nic_tx_server() function.
+///////////////////////////////////////////////////////////////////////////////////////////
+// This static function is called by the dev_nic_tx_build_packet() function.
 // It moves one ETH/IP/UDP packet from the kernel buffer identified by the <buffer> and 
 // <length> arguments to the NIC_TX_QUEUE identified the <chdev> argument.
-// It calls directly the NIC driver, without registering in a waiting queue, because 
-// only this NIC_TX server thread can access this NIC_TX_QUEUE.
-// 1) It checks NIC_TX_QUEUE status in a while loop, using the NIC_CMD_WRITABLE command.
-//    As long as the queue is not writable, it blocks and deschedules. It is re-activated 
-//    by the NIC-TX ISR as soon as the queue changes status.
-// 2) When the queue is writable, it put the ETH/IP/UDP packet into the NIC_TX_QUEUE,
-//   using the driver NIC_CMD_WRITE command.
-// Both commands are successively registered in this NIC-TX server thread descriptor
-// to be passed to the driver. 
+// It blocks and deschedules on the BLOCKED_ISR condition if the queue is full.
 ///////////////////////////////////////////////////////////////////////////////////////////
 // @ chdev   : [in] local pointer on NIC_TX chdev.
-// @ buffer  : [in] pointer on a local kernel buffer (2K bytes).
+// @ k_buf   : [in] pointer on a local kernel buffer (2K bytes).
 // @ length  : [in] actual Ethernet packet length in bytes.
 ///////////////////////////////////////////////////////////////////////////////////////////
-void dev_nic_tx_move_packet( chdev_t  * chdev,
-                             uint8_t  * buffer,
-                             uint32_t   length )
+static void dev_nic_tx_move_packet( chdev_t  * chdev,
+                                    uint8_t  * k_buf,
+                                    uint32_t   length )
 {
-    error_t    error;
-    uint32_t   writable;
-
     thread_t * this = CURRENT_THREAD;
 
@@ -2245 +1816 @@
     xptr_t     chdev_xp  = XPTR( local_cxy , chdev );
 
-    // get local pointer on core running this server thead
-    core_t * core = this->core;
-
 // check thread can yield
-assert( (this->busylocks == 0),
-"cannot yield : busylocks = %d\n", this->busylocks );
-
-#if DEBUG_DEV_NIC_RX
+thread_assert_can_yield( this , __FUNCTION__ );
+
+#if (DEBUG_DEV_NIC_TX & 1)
 uint32_t cycle = (uint32_t)hal_get_cycles();
-if( DEBUG_DEV_NIC_RX < cycle )
-printk("\n[%s] thread[%x,%x] enters for packet %x / cycle %d\n", 
-__FUNCTION__, this->process->pid, this->trdid, pkd, cycle );
-#endif
-
-    // check NIC_TX_QUEUE writable
-    while( 1 )
-    {
-        error = dev_nic_tx_queue_writable( chdev,
-                                           length,
-                                           &writable );
-        if( error )
-        {
-            printk("\n[PANIC] in %s : cannot access NIC_TX queue\n", __FUNCTION__ );
-            return;
-        }
-            
-        if( writable == 0 )  // block & deschedule if non writable
-        {
-            // enable NIC-TX IRQ 
-            dev_pic_enable_irq( core->lid , chdev_xp );
-
-            // block TX server thread
-            thread_block( thread_xp , THREAD_BLOCKED_ISR );
-
-            // deschedule TX server thread
-            sched_yield("client blocked on NIC_TX queue full");
-
-            // disable NIC-TX IRQ 
-            dev_pic_disable_irq( core->lid , chdev_xp );
-        }
-        else                // exit loop if writable
-        {
-            break;
-        }
-    }
+if( DEBUG_DEV_NIC_TX < cycle )
+printk("\n[%s] thread[%x,%x] enter / buf %x / length %d / cycle %d\n", 
+__FUNCTION__, this->process->pid, this->trdid, k_buf, length, cycle );
+#endif
 
     // initialize WRITE command in server thread descriptor
     this->nic_cmd.dev_xp = chdev_xp;
     this->nic_cmd.type   = NIC_CMD_WRITE;
-    this->nic_cmd.buffer = buffer;
+    this->nic_cmd.buffer = k_buf;
     this->nic_cmd.length = length;
 
-    // call driver to move packet
-    chdev->cmd( thread_xp );
-
-#if DEBUG_DEV_NIC_RX
+    while( 1 )
+    {
+        // call driver to move TX packet
+        chdev->cmd( thread_xp );
+
+        // exit while if success
+        if( this->nic_cmd.status == length )    // exit while & return if success
+        {
+
+#if (DEBUG_DEV_NIC_TX & 1)
 cycle = (uint32_t)hal_get_cycles();
-if( DEBUG_DEV_NIC_RX < cycle )
-printk("\n[%s] thread[%x,%x] exit for packet %x\n", 
-__FUNCTION__ , this->process->pid, this->trdid , pkd );
-#endif
-
-    return;
-
+if( DEBUG_DEV_NIC_TX < cycle )
+printk("\n[%s] thread[%x,%x] exit SUCCESS / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, cycle );
+#endif
+           break; 
+        }
+        else                                    // block and deschedule if queue full
+        {
+
+#if (DEBUG_DEV_NIC_TX & 1)
+cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_DEV_NIC_TX < cycle )
+printk("\n[%s] thread[%x,%x] NIC_TX_QUEUE full => blocks on ISR / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, cycle );
+#endif
+            // enable NIC_TX IRQ 
+            dev_pic_enable_irq( this->core->lid , chdev_xp );
+
+            // TX server thread blocks and deschedules
+            thread_block( thread_xp , THREAD_BLOCKED_ISR );
+            sched_yield("client blocked on NIC_TX queue full");
+
+            // disable NIC-TX IRQ 
+            dev_pic_disable_irq( this->core->lid , chdev_xp );
+
+#if (DEBUG_DEV_NIC_TX & 1)
+cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_DEV_NIC_TX < cycle )
+printk("\n[%s] thread[%x,%x] resumes / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, cycle );
+#endif
+        }
+    }
 }  // end dev_nic_tx_move_packet()
 
@@ -2322 +1889 @@
 // @ length     : [in]  number of bytes in payload.
 ///////////////////////////////////////////////////////////////////////////////////////////
-void dev_nic_tx_build_udp_header( uint8_t  * k_buf,
-                                  xptr_t     socket_xp,
-                                  uint32_t   length )
+static void dev_nic_tx_build_udp_header( uint8_t  * k_buf,
+                                         xptr_t     socket_xp,
+                                         uint32_t   length )
 {
     uint16_t   checksum;        // checksum value
@@ -2375 +1942 @@
 ///////////////////////////////////////////////////////////////////////////////////////////
 // @ k_buf      : [in]  pointer on first byte of TCP header in kernel buffer.
+// @ socket_xp  : [in]  extended pointer on socket.
 // @ length     : [in]  number of bytes in payload.
-// @ socket_xp  : [in]  extended pointer on socket.
 // @ flags      : [in]  flags to be set in TCP header.
 ///////////////////////////////////////////////////////////////////////////////////////////
-void dev_nic_tx_build_tcp_header( uint8_t  * k_buf,
-                                  uint32_t   length,
-                                  xptr_t     socket_xp,
-                                  uint8_t    flags )
+static void dev_nic_tx_build_tcp_header( uint8_t  * k_buf,
+                                         xptr_t     socket_xp,
+                                         uint32_t   length,
+                                         uint8_t    flags )
 {
     uint16_t   checksum;        // global segment checksum
@@ -2392 +1959 @@
     uint32_t   seq_num;         // first byte of segment in TX stream
     uint32_t   ack_num;         // next expected byte in RX stream
-    uint16_t   window;          // window of accepted segments in RX stream
+    uint32_t   window;          // window of accepted segments in RX stream
 
     // get socket cluster an local pointer
@@ -2467 +2034 @@
 // @ length     : number of bytes in IP packet payload.
 ///////////////////////////////////////////////////////////////////////////////////////////
-void dev_nic_tx_build_ip_header( uint8_t * buffer,
-                                 uint32_t  src_addr,
-                                 uint32_t  dst_addr,
-                                 uint16_t  length )
+static void dev_nic_tx_build_ip_header( uint8_t * buffer,
+                                        uint32_t  src_addr,
+                                        uint32_t  dst_addr,
+                                        uint8_t   protocol,
+                                        uint16_t  length )
 {
     uint16_t   hcs;
@@ -2487 +2055 @@
 
     buffer[8]  = 0xFF;         // TTL
-    buffer[9]  = 0x11;         // UDP protocol 
+    buffer[9]  = protocol;     // transport protocol 
     
     buffer[12] = src_addr >> 24; 
@@ -2521 +2089 @@
 // @ length     : number of bytes in Ethernet frame payload.
 ///////////////////////////////////////////////////////////////////////////////////////////
-void dev_nic_tx_build_eth_header( uint8_t * buffer,
-                                  uint16_t  src_mac_54,
-                                  uint16_t  src_mac_32,
-                                  uint16_t  src_mac_10,
-                                  uint16_t  dst_mac_54,
-                                  uint16_t  dst_mac_32,
-                                  uint16_t  dst_mac_10,
-                                  uint32_t  length )
+static void dev_nic_tx_build_eth_header( uint8_t * buffer,
+                                         uint8_t   src_mac_5,
+                                         uint8_t   src_mac_4,
+                                         uint8_t   src_mac_3,
+                                         uint8_t   src_mac_2,
+                                         uint8_t   src_mac_1,
+                                         uint8_t   src_mac_0,
+                                         uint8_t   dst_mac_5,
+                                         uint8_t   dst_mac_4,
+                                         uint8_t   dst_mac_3,
+                                         uint8_t   dst_mac_2,
+                                         uint8_t   dst_mac_1,
+                                         uint8_t   dst_mac_0,
+                                         uint32_t  length )
 {
-    buffer[0]  = dst_mac_54 >> 8;
-    buffer[1]  = dst_mac_54;
-    buffer[2]  = dst_mac_32 >> 8;
-    buffer[3]  = dst_mac_32;
-    buffer[4]  = dst_mac_10 >> 8;
-    buffer[5]  = dst_mac_10;
-
-    buffer[6]  = src_mac_54 >> 8;
-    buffer[7]  = src_mac_54;
-    buffer[8]  = src_mac_32 >> 8;
-    buffer[9]  = src_mac_32;
-    buffer[10] = src_mac_10 >> 8;
-    buffer[11] = src_mac_10;
+    buffer[0]  = dst_mac_5;
+    buffer[1]  = dst_mac_4;
+    buffer[2]  = dst_mac_3;
+    buffer[3]  = dst_mac_2;
+    buffer[4]  = dst_mac_1;
+    buffer[5]  = dst_mac_0;
+
+    buffer[6]  = src_mac_5;
+    buffer[7]  = src_mac_4;
+    buffer[8]  = src_mac_3;
+    buffer[9]  = src_mac_2;
+    buffer[10] = src_mac_1;
+    buffer[11] = src_mac_0;
 
     buffer[12] = length >> 8;
@@ -2550 +2124 @@
 
 ///////////////////////////////////////////////////////////////////////////////////////////
-// This static function is called by the dev_nic_tx_server() function to handle one 
-// TX command, or one R2T request, registered in the socket identified by the <socket_xp>
-// argument. If there is one valid command, or if the R2T queue is non empty (for a TCP
-// socket), it builds an ETH/IP/UDP packet (or a ETH/IP/TCP segment), in the buffer 
-// defined by the  <k_buf> argument, and registers it in the NIC_TX queue defined by the 
-// <chdev> argument. The supported commands are SOCKET_SEND/SOCKET_CONNECT/SOCKET_CLOSE.
-// It unblocks the client thread when the command is completed.
-///////////////////////////////////////////////////////////////////////////////////////////
-// When there is a packet to send, it makes the following actions:
+// This static function is called by the dev_nic_tx_server() function to handle one TX 
+// command, or one R2T request, as defined by the <cmd_valid> and <r2t_valid> arguments,
+// for the socket identified by the <socket_xp> argument. It builds an ETH/IP/UDP packet 
+// or ETH/IP/TCP segment, in the buffer defined by the <k_buf> argument, and registers
+// it in the NIC_TX queue defined by the <chdev> argument. 
+// For a TCP header, the "seq_num", ack_num", and "window" fiels are defined by the
+// "socket.tx_next", "socket.rx_next" and "socket.rx_wnd" fields respectively. 
+// It updates the "socket.state", "socket.tx_nxt", "socket.r2tq", and "socket.crqq" 
+// The supported TX command types are CONNECT / ACCEPT / SEND / CLOSE.
+// fields as required by the command type.
+// - For an UDP socket, it reset the "socket.tx_valid" field, and unblock the client
+//   thread when the packet has been sent, or when an error must be reported.
+// - For a TCP socket, it reset the "socket.tx_valid" field when the segment has been
+//   sent, but does not unblocks the client thread, that will be unblocqued by the 
+//   NIC_RX thread when the TX command is fully completed.
+///////////////////////////////////////////////////////////////////////////////////////////
+// To build a packet, it makes the following actions:
 // 1) it takes the lock protecting the socket state.
-// 2) it get the command arguments from client thread descriptor.
-// 3) it build an UDP packet or a TCP segment, depending on both the command type, and
-//    the socket state, updates the socket state, and unblocks the client thread.
-// 4) it release the lock protecting the socket.
-// 5) it build the IP header.
-// 6) it build the ETH header.
-// 7) it copies the packet in the NIC_TX queue.
-///////////////////////////////////////////////////////////////////////////////////////////
+// 2) it get the command arguments from socket descriptor.
+// 3) it build an UDP packet or a TCP segment, depending on command type and socket state. 
+// 4) it updates the socket state.
+// 5) it releases the lock protecting the socket.
+// 6) it build the IP header.
+// 7) it build the ETH header.
+// 8) it copies the packet in the NIC_TX queue.
+///////////////////////////////////////////////////////////////////////////////////////////
+// @ cmd_state   : [in] TX command valid in socket descriptor.
+// @ r2t_valid   : [in] R2T request valid in command descriptor. 
 // @ socket_xp   : [in] extended pointer on client socket.  
 // @ k_buf       : [in] local pointer on kernel buffer (2 Kbytes).
 // @ chdev       : [in] local pointer on NIC_RX chdev.
 ///////////////////////////////////////////////////////////////////////////////////////////
-static void dev_nic_tx_handle_one_cmd( xptr_t    socket_xp,
-                                       uint8_t * k_buf,
-                                       chdev_t * chdev )
+static void dev_nic_tx_build_packet( bool_t    cmd_valid,
+                                     bool_t    r2t_valid,
+                                     xptr_t    socket_xp,
+                                     uint8_t * k_buf,
+                                     chdev_t * chdev )
 {
     socket_t  * socket_ptr;
     cxy_t       socket_cxy;
     xptr_t      client_xp;       // extended pointer on client thread  
-    thread_t  * client_ptr;
-    cxy_t       client_cxy;
-    sock_cmd_t  cmd;             // NIC command type
-    uint8_t   * buf;             // pointer on user buffer
-    uint32_t    len;             // user buffer length
+    uint32_t    cmd_type;        // NIC command type
+    uint8_t   * tx_buf;          // local pointer on kernel buffer for payload
+    uint32_t    len;             // tx_buf length (bytes)
     uint32_t    todo;            // number of bytes not yet sent
     uint32_t    socket_type;     // socket type (UDP/TCP)
@@ -2591 +2175 @@
     uint32_t    src_ip_addr;     // source IP address
     uint32_t    dst_ip_addr;     // destination IP address
-    uint32_t    tx_una;          // next byte to be sent
-    uint32_t    tx_nxt;          // first unacknowledged byte
+    uint32_t    tx_nxt;          // next sequence number in TX stream
     uint32_t    nbytes;          // number of bytes in UDP/TCP packet payload
-    uint8_t   * k_base;          // pointer UDP/TCP packet in kernel buffer
+    uint8_t   * k_trsp_base;     // pointer on UDP/TCP packet in kernel buffer
     uint32_t    trsp_length;     // length of TCP/UDP packet
+    uint8_t     trsp_protocol;   // transport protocol type (UDP/TCP)
     uint8_t     r2t_flags;       // flags defined by one R2T queue request
     bool_t      do_send;         // build & send a packet when true
@@ -2602 +2186 @@
     socket_cxy = GET_CXY( socket_xp );
     socket_ptr = GET_PTR( socket_xp );
-    
-    // build extended pointer on socket lock and r2t queue
-    socket_lock_xp = XPTR( socket_cxy , &socket_ptr->lock );
+
+#if DEBUG_DEV_NIC_TX 
+thread_t * this = CURRENT_THREAD;;
+uint32_t   cycle = (uint32_t)hal_get_cycles();
+uint32_t   fdid  = hal_remote_l32( XPTR( socket_cxy , &socket_ptr->fdid ));
+uint32_t   pid   = hal_remote_l32( XPTR( socket_cxy , &socket_ptr->pid ));
+if( cycle > DEBUG_DEV_NIC_TX )
+printk("\n[%s] thread[%x,%x] enter for socket[%x,%d] : cmd_valid %d / r2t_valid %d / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, pid, fdid, cmd_valid, r2t_valid, cycle );
+#endif
+
+    // build extended pointers on socket lock and r2t queue
+    socket_lock_xp = XPTR( socket_cxy , &socket_ptr->lock );    
     socket_r2tq_xp = XPTR( socket_cxy , &socket_ptr->r2tq );
 
     // 1. take lock protecting this socket
-    remote_rwlock_wr_acquire( socket_lock_xp );
-
-    // get pointers on TX client thread from socket
-    client_xp = hal_remote_l64( XPTR( socket_cxy , &socket_ptr->tx_client ));
-    client_cxy = GET_CXY( client_xp );
-    client_ptr = GET_PTR( client_xp );
-
-    // check valid command 
-    if( client_xp != XPTR_NULL )   // valid command found
+    remote_queuelock_acquire( socket_lock_xp );
+
+    // get relevant socket infos
+    socket_type  = hal_remote_l32( XPTR( socket_cxy , &socket_ptr->type ));
+    socket_state = hal_remote_l32( XPTR( socket_cxy , &socket_ptr->state ));
+    src_ip_addr  = hal_remote_l32( XPTR( socket_cxy , &socket_ptr->local_addr ));
+    dst_ip_addr  = hal_remote_l32( XPTR( socket_cxy , &socket_ptr->remote_addr ));
+
+    // compute UDP/TCP packet base in kernel buffer
+    k_trsp_base = k_buf + ETH_HEAD_LEN + IP_HEAD_LEN;
+
+    // set default values
+    do_send     = false;
+    trsp_length = 0;
+    nbytes      = 0;
+
+    if( cmd_valid )  // handle TX command 
     {
         // 2. get command arguments from socket
-        cmd  = hal_remote_l32( XPTR(socket_cxy , &socket_ptr->tx_cmd ));
-        buf  = hal_remote_lpt( XPTR(socket_cxy , &socket_ptr->tx_buf ));
-        len  = hal_remote_l32( XPTR(socket_cxy , &socket_ptr->tx_len ));
-        todo = hal_remote_l32( XPTR(socket_cxy , &socket_ptr->tx_todo ));
+        cmd_type  = hal_remote_l32( XPTR( socket_cxy , &socket_ptr->tx_cmd ));
+        tx_buf    = hal_remote_lpt( XPTR( socket_cxy , &socket_ptr->tx_buf ));
+        len       = hal_remote_l32( XPTR( socket_cxy , &socket_ptr->tx_len ));
+        todo      = hal_remote_l32( XPTR( socket_cxy , &socket_ptr->tx_todo ));
+        client_xp = hal_remote_l64( XPTR( socket_cxy , &socket_ptr->tx_client ));
         
-        // get socket type and state
-        socket_type  = hal_remote_l32( XPTR(socket_cxy , &socket_ptr->type ));
-        socket_state = hal_remote_l32( XPTR(socket_cxy , &socket_ptr->state ));
-
+#if DEBUG_DEV_NIC_TX 
+cycle = (uint32_t)hal_get_cycles();
+if( cycle > DEBUG_DEV_NIC_TX )
+printk("\n[%s] thread[%x,%x] cmd_valid for socket[%x,%d] : %s / %s / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, pid, fdid,
+socket_cmd_type_str(cmd_type), socket_state_str(socket_state), cycle );
+#endif
+
+        //////////////////////////////////////////////////////////
         // 3. UDP : build UDP packet and update UDP socket state
         if( socket_type == SOCK_DGRAM )        
         {
-            if( socket_state == UDP_STATE_UNBOUND )
+            trsp_protocol = PROTOCOL_UDP;
+
+            if( socket_state != UDP_STATE_ESTAB )
             {
-                // report illegal command
-                dev_nic_tx_report_error( socket_xp, cmd, socket_state );
-
-                do_send = false;
+                // reset tx_valid
+                hal_remote_s32( XPTR( socket_cxy , &socket_ptr->tx_valid ) , false );
+
+                // unblock client thread / report error
+                dev_nic_unblock_tx_client( socket_xp , CMD_STS_BADSTATE );
             }
-            else  // BOUND or CONNECT state
+            else
             {
-                if( cmd == SOCKET_TX_SEND ) 
+                if( cmd_type == CMD_TX_SEND ) 
                 {
                     // compute payload length
                     nbytes = ( PAYLOAD_MAX_LEN < todo ) ? PAYLOAD_MAX_LEN : todo;
 
-                    // compute UDP packet base in kernel buffer
-                    k_base = k_buf + ETH_HEAD_LEN + IP_HEAD_LEN;
-
-                    // move payload to kernel buffer
-                    hal_copy_from_uspace( XPTR(local_cxy , k_base + UDP_HEAD_LEN ),
-                                          buf + (len - todo),
-                                          nbytes );
+                    // move payload from tx_buf to 2 Kbytes kernel buffer
+                    memcpy( k_trsp_base + UDP_HEAD_LEN,
+                            tx_buf + (len - todo),
+                            nbytes );
+
                     // build UDP header 
-                    dev_nic_tx_build_udp_header( k_base,
+                    dev_nic_tx_build_udp_header( k_trsp_base,
                                                  socket_xp,
                                                  nbytes );
 
                     // update "tx_todo" in socket descriptor 
-                    hal_remote_s32( XPTR(socket_cxy , socket_ptr->tx_todo),
-                                    todo - nbytes );
-
-                    // unblock client thread when SEND command completed
-                    if( nbytes == todo )
+                    hal_remote_s32( XPTR(socket_cxy , &socket_ptr->tx_todo), todo - nbytes );
+
+                    // send UDP packet 
+                    trsp_length = UDP_HEAD_LEN + nbytes;
+                    do_send     = true;
+
+#if( DEBUG_DEV_NIC_TX & 1)
+cycle = (uint32_t)hal_get_cycles();
+if( cycle > DEBUG_DEV_NIC_TX )
+printk("\n[%s] thread[%x,%x] socket[%x,%d] UDP packet build / length %d / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, trsp_length , cycle );
+#endif
+                    if( nbytes == todo )    // last byte sent
                     {
-                        dev_nic_tx_report_success( socket_xp );
+                        // reset tx_valid
+                        hal_remote_s32( XPTR( socket_cxy , &socket_ptr->tx_valid ) , false );
+
+                        // report success to TX client
+                        dev_nic_unblock_tx_client( socket_xp , CMD_STS_SUCCESS );
                     }
-
-                    do_send = true;
-                }
-                else
-                {
-                    // report illegal command
-                    dev_nic_tx_report_error( socket_xp, cmd, socket_state );
-
-                    do_send = false;
+                }
+                else // CONNECT, ACCEPT, or CLOSE commands are illegal for UDP
+                {
+                    // reset tx_valid
+                    hal_remote_s32( XPTR( socket_cxy , &socket_ptr->tx_valid ) , false );
+
+                    // report error
+                    dev_nic_unblock_tx_client( socket_xp , CMD_STS_BADCMD );
                 }
             }
-
-            // compute transport packet length
-            trsp_length = UDP_HEAD_LEN + nbytes;
-
         }  // end UDP
 
+        ///////////////////////////////////////////////////////////
         // 3. TCP : build TCP segment and update TCP socket state
-        if( socket_type == SOCK_STREAM ) 
+        else if( socket_type == SOCK_STREAM ) 
         {
-            // extract one request from TCP socket R2T queue if queue non empty
-            if( remote_buf_status( socket_r2tq_xp ) )
+            trsp_protocol = PROTOCOL_TCP;
+
+            // handle R2T request / initialize r2t_flags
+            if( r2t_valid )
             {
+                // build extended pointers on r2t queue
+                socket_r2tq_xp = XPTR( socket_cxy , &socket_ptr->r2tq );
+        
+                // get one request from R2T queue 
                 remote_buf_get_to_kernel( socket_r2tq_xp , &r2t_flags , 1 );
             }
@@ -2696 +2319 @@
             }
 
+            ////////////////////////////////
+            if( cmd_type == CMD_TX_CONNECT )  // always executed by a TCP client
+            {
+                if( (socket_state == TCP_STATE_BOUND) ||
+                    (socket_state == TCP_STATE_LISTEN) )  // send a SYN segment
+                {
+                    // initialises socket tx_nxt, and rx_wnd
+                    hal_remote_s32(XPTR(socket_cxy , &socket_ptr->tx_nxt), TCP_ISS_CLIENT );
+                    hal_remote_s32(XPTR(socket_cxy , &socket_ptr->rx_wnd), TCP_MAX_WINDOW );
+
+                    // build TCP SYN segment
+                    dev_nic_tx_build_tcp_header( k_trsp_base,
+                                                 socket_xp,
+                                                 0,        // length
+                                                 TCP_FLAG_SYN );   
+                    // send segment
+                    trsp_length = TCP_HEAD_LEN;
+                    do_send     = true;
+
+#if DEBUG_DEV_NIC_TX 
+cycle = (uint32_t)hal_get_cycles();
+if( cycle > DEBUG_DEV_NIC_TX )
+printk("\n[%s] thread[%x,%x] socket[%x,%d] %s / CONNECT / "
+"TCP SYN build / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, pid, fdid,
+socket_state_str( socket_state ), cycle );
+#endif
+                    // update socket.state 
+                    hal_remote_s32( XPTR( socket_cxy , &socket_ptr->state ),
+                                          TCP_STATE_SYN_SENT );
+
+                    // update socket.tx_nxt
+                    hal_remote_s32( XPTR( socket_cxy , &socket_ptr->tx_nxt ),
+                                          TCP_ISS_CLIENT + 1 );
+
+                    // reset tx_valid but do not unblock client thread
+                    hal_remote_s32( XPTR( socket_cxy , &socket_ptr->tx_valid ), false );
+                } 
+                else                      // report error for all other socket states
+                {
+                    // reset tx_valid
+                    hal_remote_s32( XPTR( socket_cxy , &socket_ptr->tx_valid ) , false );
+                   
+                    // report error
+                    dev_nic_unblock_tx_client( socket_xp , CMD_STS_BADSTATE ); 
+                }
+            }
+            ////////////////////////////////////
+            else if( cmd_type == CMD_TX_ACCEPT )   // always executed by a TCP server
+            {
+
+                if( socket_state == TCP_STATE_SYN_RCVD )  // send a SYN-ACK segment
+                {
+                    // initialize socket tx_nxt, and rx_wnd
+                    hal_remote_s32(XPTR(socket_cxy , &socket_ptr->tx_nxt), TCP_ISS_SERVER );
+                    hal_remote_s32(XPTR(socket_cxy , &socket_ptr->rx_wnd), NIC_RX_BUF_SIZE);
+                
+                    // build TCP ACK-SYN segment
+                    dev_nic_tx_build_tcp_header( k_trsp_base,
+                                                 socket_xp,
+                                                 0,         //  length
+                                                 TCP_FLAG_SYN | TCP_FLAG_ACK );
+                    // send segment
+                    trsp_length = TCP_HEAD_LEN;
+                    do_send     = true;
+
+#if DEBUG_DEV_NIC_TX 
+cycle = (uint32_t)hal_get_cycles();
+if( cycle > DEBUG_DEV_NIC_TX )
+printk("\n[%s] thread[%x,%x] socket[%x,%d] %s / ACCEPT / send SYN-ACK / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, pid, fdid,
+socket_state_str( socket_state ), cycle );
+#endif
+                    // update socket.state 
+                    hal_remote_s32( XPTR( socket_cxy , &socket_ptr->state ),
+                                          TCP_STATE_SYN_RCVD );
+
+                    // update socket.tx_nxt
+                    hal_remote_s32( XPTR( socket_cxy , &socket_ptr->tx_nxt ),
+                                          TCP_ISS_SERVER + 1 );
+
+                    // reset tx_valid but do not unblock client thread
+                    hal_remote_s32( XPTR( socket_cxy , &socket_ptr->tx_valid ), false );
+                }
+                else                     // report error in all other socket states
+                {
+                    // reset tx_valid
+                    hal_remote_s32( XPTR( socket_cxy , &socket_ptr->tx_valid ), false );
+
+                    // report error to TX client thread
+                    dev_nic_unblock_tx_client( socket_xp , CMD_STS_BADSTATE );
+                }
+            }
+            ///////////////////////////////////
+            else if( cmd_type == CMD_TX_CLOSE )
+            {
+                if( (socket_state == TCP_STATE_SYN_RCVD  ) ||
+                    (socket_state == TCP_STATE_ESTAB     ) ||
+                    (socket_state == TCP_STATE_CLOSE_WAIT) )   // send a FIN-ACK segment
+                {
+                    // get  "tx_nxt" from socket descriptor
+                    tx_nxt = hal_remote_l32( XPTR(socket_cxy , &socket_ptr->tx_nxt ));
+
+                    // compute next state
+                    uint32_t state = (socket_state == TCP_STATE_CLOSE_WAIT) ?
+                                     TCP_STATE_LAST_ACK : TCP_STATE_FIN_WAIT1;
+
+                    // update socket state 
+                    hal_remote_s32( XPTR( socket_cxy , &socket_ptr->state ), state );
+
+                    // build TCP FIN segment
+                    dev_nic_tx_build_tcp_header( k_trsp_base,
+                                                 socket_xp,
+                                                 0,         // length
+                                                 TCP_FLAG_FIN | TCP_FLAG_ACK );   
+
+                    // update "tx_nxt" in socket descriptor
+                    hal_remote_s32( XPTR(socket_cxy , &socket_ptr->tx_nxt), tx_nxt + 1 );
+
+                    // send segment
+                    trsp_length = TCP_HEAD_LEN;
+                    do_send     = true;
+
+#if DEBUG_DEV_NIC_TX 
+cycle = (uint32_t)hal_get_cycles();
+if( cycle > DEBUG_DEV_NIC_TX )
+printk("\n[%s] thread[%x,%x] socket[%x,%d] %s / CLOSE / send FIN-ACK / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, pid, fdid,
+socket_state_str( socket_state ), cycle );
+#endif
+                    // reset tx_valid but do not unblock client thread
+                    hal_remote_s32( XPTR( socket_cxy , &socket_ptr->tx_valid ), false );
+                }
+                else                                 // all other states => signal error
+                {
+
+#if DEBUG_DEV_NIC_TX 
+cycle = (uint32_t)hal_get_cycles();
+if( cycle > DEBUG_DEV_NIC_TX )
+printk("\n[%s] thread[%x,%x] socket[%x,%d] %s / CLOSE / error BADSTATE / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, pid, fdid,
+socket_state_str( socket_state ), cycle );
+#endif
+                    // reset tx_valid
+                    hal_remote_s32( XPTR( socket_cxy , &socket_ptr->tx_valid ), false );
+
+                    // report error 
+                    dev_nic_unblock_tx_client( socket_xp , CMD_STS_BADSTATE );
+                }
+            }
             /////////////////////////////////////
-            if( socket_state == TCP_STATE_ESTAB )    // connected TCP socket
+            else if( cmd_type == CMD_TX_SEND )
             {
-                if( cmd == SOCKET_TX_SEND )          
-                {
-                    // get  "tx_nxt", and "tx_una" from socket descriptor
+                if( (socket_state == TCP_STATE_ESTAB     ) ||
+                    (socket_state == TCP_STATE_CLOSE_WAIT) )
+                {
+                    // get  "tx_nxt" from socket descriptor
                     tx_nxt = hal_remote_l32( XPTR(socket_cxy , &socket_ptr->tx_nxt ));
-                    tx_una = hal_remote_l32( XPTR(socket_cxy , &socket_ptr->tx_una ));
 
                     // compute actual payload length
@@ -2709 +2482 @@
 
                     // compute TCP segment base in kernel buffer
-                    k_base = k_buf + ETH_HEAD_LEN + IP_HEAD_LEN;
-
-                    // move payload to kernel buffer
-                    hal_copy_from_uspace( XPTR( local_cxy , k_base + TCP_HEAD_LEN ),
-                                          buf + (len - todo),
-                                          nbytes );
+                    k_trsp_base = k_buf + ETH_HEAD_LEN + IP_HEAD_LEN;
+
+                    // move payload to k_buf
+                    memcpy( k_trsp_base + TCP_HEAD_LEN,
+                            tx_buf + (len - todo),
+                            nbytes );
 
                     // build TCP header 
-                    dev_nic_tx_build_tcp_header( k_base,
+                    dev_nic_tx_build_tcp_header( k_trsp_base,
                                                  socket_xp,
                                                  nbytes,                       // payload
@@ -2723 +2496 @@
 
                     // update "tx_todo" in socket descriptor
-                    hal_remote_s32( XPTR( socket_cxy , &socket_ptr->tx_todo ),
-                                    todo - nbytes );
+                    hal_remote_s32( XPTR(socket_cxy , &socket_ptr->tx_todo), todo - nbytes );
 
                     // update "tx_nxt" in socket descriptor
-                    hal_remote_s32( XPTR( socket_cxy , &socket_ptr->tx_nxt ),
-                                    tx_nxt + nbytes );
-
-                    // unblock client thread when SEND command completed
-                    if( (todo == 0) && (tx_nxt == tx_una) ) 
+                    hal_remote_s32( XPTR(socket_cxy , &socket_ptr->tx_nxt), tx_nxt + nbytes );
+
+                    // send TCP segment
+                    trsp_length = TCP_HEAD_LEN + nbytes;
+                    do_send     = true;
+
+                    if( todo == nbytes )   // last byte sent 
                     {
-                        dev_nic_tx_report_success( socket_xp );
+                        // reset tx_valid when last byte has been sent
+                        hal_remote_s32( XPTR(socket_cxy , &socket_ptr->tx_valid), false );
                     }
 
-                    do_send = true;
-                }
-                else if( cmd == SOCKET_TX_CLOSE )          
-                {
-                    // build TCP FIN segment
-                    dev_nic_tx_build_tcp_header( k_base,
-                                                 socket_xp,
-                                                 0,                            // payload
-                                                 TCP_FLAG_FIN | r2t_flags );   // flags
-                    // update socket state
-                    hal_remote_s32( XPTR( socket_cxy , &socket_ptr->state ),
-                                    TCP_STATE_FIN_WAIT1 );
-
-                    do_send = true;
-                }
-                else  // cmd == CONNECT
-                {
-                    // report illegal command
-                    dev_nic_tx_report_error( socket_xp , cmd , socket_state );
-
-                    do_send = false;
+#if DEBUG_DEV_NIC_TX 
+cycle = (uint32_t)hal_get_cycles();
+if( cycle > DEBUG_DEV_NIC_TX )
+printk("\n[%s] thread[%x,%x] socket[%x,%d] %s / SEND / "
+"TCP DATA build / payload %d / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, pid, fdid,
+socket_state_str( socket_state ), nbytes, cycle );
+#endif
+                }
+                else  // all other socket states
+                {
+                    // reset tx_valid
+                    hal_remote_s32( XPTR( socket_cxy , &socket_ptr->tx_valid ), false );
+
+                    // report error to TX client thread
+                    dev_nic_unblock_tx_client( socket_xp , CMD_STS_BADSTATE );
                 }
             }
-            //////////////////////////////////////////
-            else if( socket_state == TCP_STATE_BOUND )  // unconnected TCP socket
+            ///////////////////////////////////
+            else  // undefined TX command type
             {
-                if ( cmd == SOCKET_TX_CONNECT )  
-                {
-                    // set socket.tx_nxt
-                    hal_remote_s32( XPTR( socket_cxy , &socket_ptr->tx_nxt ),
-                                     TCP_ISS  );
-                     
-                    hal_remote_s32( XPTR( socket_cxy , &socket_ptr->rx_nxt ), 0 );
-                    hal_remote_s32( XPTR( socket_cxy , &socket_ptr->rx_wnd ),
-                                    NIC_RX_BUF_SIZE);
-                                     
-                    // build TCP SYN segment
-                    dev_nic_tx_build_tcp_header( k_base,
-                                                  socket_xp,
-                                                  0,                // payload
-                                                  TCP_FLAG_SYN );   // flags
-                    // update socket state
-                    hal_remote_s32( XPTR( socket_cxy , &socket_ptr->state ),
-                                     TCP_STATE_SYN_SENT );
-
-                    do_send = true;
-                }
-                else   // cmd == SEND / CLOSE
-                {
-                    // report illegal command
-                    dev_nic_tx_report_error( socket_xp, cmd, socket_state );
-
-                    do_send = false;
-                }
+                // reset tx_valid
+                hal_remote_s32( XPTR( socket_cxy , &socket_ptr->tx_valid ), false );
+
+                // report error to TX client thread
+                dev_nic_unblock_tx_client( socket_xp , CMD_STS_BADCMD );
             }
-            ///////////////////////////////////////////
-            else if( socket_state == TCP_STATE_LISTEN )  // server wait connect
-            {
-                if( cmd == SOCKET_TX_CONNECT )          
-                {
-                    // update socket.state
-                    hal_remote_s32( XPTR( socket_cxy , &socket_ptr->state ),
-                                    TCP_STATE_SYN_SENT );
-                    
-                    // set socket.tx_una  
-                    hal_remote_s32( XPTR( socket_cxy , &socket_ptr->tx_una ),
-                                    TCP_ISS );
-
-                    // set socket.tx_nxt 
-                    hal_remote_s32( XPTR( socket_cxy , &socket_ptr->tx_una ),
-                                    TCP_ISS + 1 );
-
-                    // build TCP SYN segment
-                    dev_nic_tx_build_tcp_header( k_base,
-                                                 socket_xp,
-                                                 0,                // payload
-                                                 TCP_FLAG_SYN );   // flags
-                    do_send = true;
-                }
-                else  // cmd == CLOSE / SEND
-                {
-                    // report illegal command
-                    dev_nic_tx_report_error( socket_xp, cmd, socket_state );
-
-                    do_send = false;
-                }
-            }
-            /////////////////////////////////////////////
-            else if( socket_state == TCP_STATE_SYN_RCVD )  // socket wait ACK
-            {
-                if( cmd == SOCKET_TX_CLOSE )          
-                {
-                    // build TCP FIN segment
-                    dev_nic_tx_build_tcp_header( k_base,
-                                                 socket_xp,
-                                                 0,                // payload
-                                                 TCP_FLAG_FIN );   // flags
-                    // update socket state 
-                    hal_remote_s32( XPTR( socket_cxy , &socket_ptr->state ),
-                                    TCP_STATE_FIN_WAIT1 );
-
-                    do_send = true;
-                }
-                else  // SEND / CONNECT
-                {
-                    // report illegal command
-                    dev_nic_tx_report_error( socket_xp, cmd, socket_state );
-
-                    do_send = false;
-                }
-            }
-            ////////////////////////////////////////////////
-            else if( socket_state == TCP_STATE_CLOSE_WAIT )  // wait local close()
-            {
-                if( cmd == SOCKET_TX_CLOSE )          
-                {
-                    // build TCP FIN segment
-                    dev_nic_tx_build_tcp_header( k_base,
-                                                 socket_xp,
-                                                 0,                // payload
-                                                 TCP_FLAG_FIN );   // flags
-                    // update socket state 
-                    hal_remote_s32( XPTR( socket_cxy , &socket_ptr->state ),
-                                    TCP_STATE_LAST_ACK );
-
-                    do_send = true;
-                }
-                else  // SEND / CONNECT
-                {
-                    // report illegal command
-                    dev_nic_tx_report_error( socket_xp, cmd, socket_state );
-
-                    do_send = false;
-                }
-            }
-            ////
-            else
-            {
-                    // report illegal command
-                    dev_nic_tx_report_error( socket_xp, cmd, socket_state );
-
-                    do_send = false;
-            }
-
-            // compute TCP segment length
-            trsp_length = TCP_HEAD_LEN + nbytes;
-        }
-    }  
-    else                        // no valid command found
+        }  // end TCP 
+    }
+    else         // no valid TX command => handle R2T request only
     {
-        if( socket_type == SOCK_DGRAM )    //  UDP socket
-        {
-            do_send = false;
-        }
-        else                               //  TCP socket
-        {
-            if( remote_buf_status( socket_r2tq_xp ) == 0 )  // R2T queue empty
-            {
-                do_send = false;
-            }
-            else                                // pending request in R2T queue
-            {
-                // get one request from R2T queue 
-                remote_buf_get_to_kernel( socket_r2tq_xp , &r2t_flags , 1 );
-
-                // build TCP header for an empty segment
-                dev_nic_tx_build_tcp_header( k_base,
-                                             socket_xp,
-                                             0,             // payload
-                                             r2t_flags );   // flags
-                do_send = true;
-            }          
-        }
+        // get one request from R2T queue 
+        remote_buf_get_to_kernel( socket_r2tq_xp , &r2t_flags , 1 );
+
+#if DEBUG_DEV_NIC_TX 
+cycle = (uint32_t)hal_get_cycles();
+if( cycle > DEBUG_DEV_NIC_TX )
+printk("\n[%s] thread[%x,%x] only r2t_valid for socket[%x,%d] / flags %x / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, pid, fdid, r2t_flags, cycle );
+#endif
+
+        // build TCP header 
+        dev_nic_tx_build_tcp_header( k_trsp_base,
+                                     socket_xp,
+                                     0,             // payload length
+                                     r2t_flags );   // flags
+        // send TCP segment
+        trsp_protocol = PROTOCOL_TCP;
+        trsp_length   = TCP_HEAD_LEN;
+        do_send       = true;
     }
 
     // 4. release the lock protecting the socket
-    remote_rwlock_wr_release( socket_lock_xp );
+    remote_queuelock_release( socket_lock_xp );
 
     // return if no packet to send
@@ -2921 +2573 @@
                                 src_ip_addr,
                                 dst_ip_addr,
-                                IP_HEAD_LEN + trsp_length );
+                                trsp_protocol,
+                                trsp_length );
+
+#if( DEBUG_DEV_NIC_TX & 1)
+cycle = (uint32_t)hal_get_cycles();
+if( cycle > DEBUG_DEV_NIC_TX )
+printk("\n[%s] thread[%x,%x] IP header build / length %d / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, IP_HEAD_LEN + trsp_length , cycle );
+#endif
 
     // 6. build ETH header
     dev_nic_tx_build_eth_header( k_buf,
-                                 (uint16_t)SRC_MAC_54,
-                                 (uint16_t)SRC_MAC_32,
-                                 (uint16_t)SRC_MAC_10,
-                                 (uint16_t)DST_MAC_54,
-                                 (uint16_t)DST_MAC_32,
-                                 (uint16_t)DST_MAC_10,
-                                 ETH_HEAD_LEN + IP_HEAD_LEN + trsp_length );
-
-    // 7. move packet to NIC_TX queue
+                                 (uint8_t)DST_MAC_5,
+                                 (uint8_t)DST_MAC_4,
+                                 (uint8_t)DST_MAC_3,
+                                 (uint8_t)DST_MAC_2,
+                                 (uint8_t)DST_MAC_1,
+                                 (uint8_t)DST_MAC_0,
+                                 (uint8_t)SRC_MAC_5,
+                                 (uint8_t)SRC_MAC_4,
+                                 (uint8_t)SRC_MAC_3,
+                                 (uint8_t)SRC_MAC_2,
+                                 (uint8_t)SRC_MAC_1,
+                                 (uint8_t)SRC_MAC_0,
+                                 IP_HEAD_LEN + trsp_length );
+
+#if( DEBUG_DEV_NIC_TX & 1)
+cycle = (uint32_t)hal_get_cycles();
+if( cycle > DEBUG_DEV_NIC_TX )
+printk("\n[%s] thread[%x,%x] ETH header build / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, cycle );
+#endif
+
+    // 7. move packet to NIC_TX queue (blocking function)
     dev_nic_tx_move_packet( chdev,
                             k_buf,
                             ETH_HEAD_LEN + IP_HEAD_LEN + trsp_length );
 
-}  // end dev_nic_tx_handle_one_cmd()
+#if DEBUG_DEV_NIC_TX
+cycle = (uint32_t)hal_get_cycles();
+if( cycle > DEBUG_DEV_NIC_TX )
+printk("\n[%s] thread[%x,%x] for socket[%x,%d] moved packet to NIC_TX / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, pid, fdid, cycle );
+#endif
+
+}  // end dev_nic_tx_build_packet()
+
 
 /////////////////////////////////////////
@@ -2945 +2626 @@
     uint8_t       k_buf[NIC_KERNEL_BUF_SIZE];  // buffer for one packet
 
-    xptr_t        root_xp;         // extended pointer on clients list root
-    xptr_t        lock_xp;         // extended pointer on lock protecting this list
-    xptr_t        socket_xp;       // extended pointer on on client socket 
+    xptr_t        queue_root_xp;       // extended pointer on sockets list root
+    xptr_t        queue_lock_xp;       // extended pointer on lock protecting this list
+    xptr_t        socket_xp;           // extended pointer on on registered socket 
     socket_t    * socket_ptr;
     cxy_t         socket_cxy;
-    xptr_t        entry_xp;        // extended pointer on socket tx_list entry
+    xptr_t        iter_xp;             // iterator for loop on registered sockets
+    xlist_entry_t temp_root;           // root of temporary list of sockets
+    xptr_t        temp_root_xp;        // extended pointer on temporary list of sockets
+    uint32_t      temp_nr;             // number of active registered sockets
+    bool_t        cmd_valid;           // TX command valid in socket descriptor
+    bool_t        r2t_valid;           // valid R2T request in socket descriptor
 
     thread_t * this = CURRENT_THREAD;
+
+#if DEBUG_DEV_NIC_TX
+uint32_t cycle = (uint32_t)hal_get_cycles();
+uint32_t pid;
+uint32_t fdid;
+if( cycle > DEBUG_DEV_NIC_TX )
+printk("\n[%s] thread[%x,%x] starts / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, cycle );
+#endif
 
 // check chdev direction and type
@@ -2959 +2654 @@
 
 // check thread can yield
-assert( (this->busylocks == 0),
-"cannot yield : busylocks = %d\n", this->busylocks );
-
-    // build extended pointer on client sockets lock & root 
-    lock_xp = XPTR( local_cxy , &chdev->wait_lock );
-    root_xp = XPTR( local_cxy , &chdev->wait_root );
+thread_assert_can_yield( this , __FUNCTION__ );
+
+    // build extended pointer on temporary list
+    temp_root_xp = XPTR( local_cxy , &temp_root );
+                                                         
+    // build extended pointer on client sockets queue (lock & root) 
+    queue_lock_xp = XPTR( local_cxy , &chdev->wait_lock );
+    queue_root_xp = XPTR( local_cxy , &chdev->wait_root );
 
     while( 1 )  // TX server infinite loop
     {
+        // initialize temporary list of registered sockets as empty
+        xlist_root_init( temp_root_xp );
+        temp_nr = 0;
+
         // take the lock protecting the client sockets queue
-        remote_busylock_acquire( lock_xp );
-
-        /////////////// block and deschedule if no clients
-        if( xlist_is_empty( root_xp ) == false )
+        remote_busylock_acquire( queue_lock_xp );
+
+        // build temporary list of all registered sockets
+        if( xlist_is_empty( queue_root_xp ) == false )  
         {
-            // release the lock protecting the TX client sockets queue
-            remote_busylock_release( lock_xp );
+            XLIST_FOREACH( queue_root_xp , iter_xp )
+            {
+                // get client socket cluster and local pointer
+                socket_xp  = XLIST_ELEMENT( iter_xp , socket_t , tx_list );
+                socket_ptr = GET_PTR( socket_xp );
+                socket_cxy = GET_CXY( socket_xp );
+
+                // register socket in temporary list
+                xlist_add_last( temp_root_xp , XPTR( socket_cxy , &socket_ptr->tx_temp ));
+                temp_nr++;
+            }
+        }
+
+        // release the lock protecting the client sockets queue
+        remote_busylock_release( queue_lock_xp );
+
+        if( temp_nr > 0 )
+        {
+            // loop on temporary list
+            XLIST_FOREACH( temp_root_xp , iter_xp )
+            {
+                // get client socket cluster and local pointer
+                socket_xp  = XLIST_ELEMENT( iter_xp , socket_t , tx_temp );
+                socket_ptr = GET_PTR( socket_xp );
+                socket_cxy = GET_CXY( socket_xp );
+
+                // get cmd_valid & t2t_valid from socket descriptor
+                cmd_valid = hal_remote_l32( XPTR( socket_cxy , &socket_ptr->tx_valid ));
+
+                // get r2t_valid from socket descriptor
+                r2t_valid = (bool_t)remote_buf_status( XPTR( socket_cxy , &socket_ptr->r2tq ));
+
+                // test if socket is active
+                if( cmd_valid || r2t_valid )  // active socket 
+                {
+
+#if DEBUG_DEV_NIC_TX
+cycle = (uint32_t)hal_get_cycles();
+pid  = hal_remote_l32( XPTR( socket_cxy , &socket_ptr->pid ));
+fdid = hal_remote_l32( XPTR( socket_cxy , &socket_ptr->fdid ));
+if( cycle > DEBUG_DEV_NIC_TX )
+printk("\n[%s] thread[%x,%x] found socket[%x,%d] / cmd_valid %d / r2t_valid %d / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, pid, fdid, cmd_valid, r2t_valid, cycle );
+#endif
+                    // build and send one packet/segment for this socket
+                    dev_nic_tx_build_packet( cmd_valid,
+                                             r2t_valid,
+                                             socket_xp,
+                                             k_buf,
+                                             chdev );
+#if DEBUG_DEV_NIC_TX
+cycle = (uint32_t)hal_get_cycles();
+if( cycle > DEBUG_DEV_NIC_TX )
+dev_nic_packet_display( true,                // is_tx
+                        this->process->pid,
+                        this->trdid,
+                        cycle,
+                        k_buf );
+#endif
+                }
+                else                          // inactive socket
+                {
+                   temp_nr--;
+                }
+            }  // end loop on temporary list
+        }
+
+        // block & deschedule if no active socket found in current iteration
+        if( temp_nr == 0 )
+        {
  
+#if DEBUG_DEV_NIC_TX
+cycle = (uint32_t)hal_get_cycles();
+if( cycle > DEBUG_DEV_NIC_TX )
+printk("\n[%s] thread[%x,%x] no active socket => blocks on <CLIENT> / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, cycle );
+#endif
+
             // block and deschedule
             thread_block( XPTR( local_cxy , this ) , THREAD_BLOCKED_CLIENT );
             sched_yield( "waiting client" );
+
+#if DEBUG_DEV_NIC_TX
+cycle = (uint32_t)hal_get_cycles();
+if( cycle > DEBUG_DEV_NIC_TX )
+printk("\n[%s] thread[%x,%x] resumes / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, cycle );
+#endif
         }
-        //////////////  
-        else
-        {
-            // get first client socket
-            socket_xp  = XLIST_FIRST( root_xp , socket_t , tx_list );
-            socket_cxy = GET_CXY( socket_xp );
-            socket_ptr = GET_PTR( socket_xp );
- 
-            // build extended pointer on socket xlist_entry
-            entry_xp = XPTR( socket_cxy , &socket_ptr->tx_list );
-
-            // remove this socket from the waiting queue
-            xlist_unlink( entry_xp );
-
-            // release the lock protecting the client sockets queue
-            remote_busylock_release( lock_xp );
-
-            // handle this TX client
-            dev_nic_tx_handle_one_cmd( socket_xp,
-                                       k_buf,
-                                       chdev ); 
-
-            // take the lock protecting the client sockets queue
-            remote_busylock_acquire( lock_xp );
-
-            // add this socket in last position of queue
-            xlist_add_last( root_xp , entry_xp ); 
-
-            // release the lock protecting the client sockets queue
-            remote_busylock_release( lock_xp );
-        }
-    }   // end while
+    }   // end infinite while loop
 }  // end dev_nic_tx_server()
 
 
+/////////////////////////////////////////////
+void dev_nic_packet_display( bool_t    is_tx,
+                             pid_t     thread_pid,
+                             trdid_t   thread_trdid,
+                             uint32_t  cycle,
+                             uint8_t * buf )
+{
+    // get ETH header fields
+    uint64_t eth_dst_mac = ((uint64_t)buf[5]  << 40) |
+                           ((uint64_t)buf[4]  << 32) |
+                           ((uint64_t)buf[3]  << 24) |
+                           ((uint64_t)buf[2]  << 16) |
+                           ((uint64_t)buf[1]  <<  8) |
+                           ((uint64_t)buf[0]       ) ;
+
+    uint64_t eth_src_mac = ((uint64_t)buf[11] << 40) |
+                           ((uint64_t)buf[10] << 32) |
+                           ((uint64_t)buf[9]  << 24) |
+                           ((uint64_t)buf[8]  << 16) |
+                           ((uint64_t)buf[7]  <<  8) |
+                           ((uint64_t)buf[6]       ) ;
+
+    uint16_t eth_length  = ((uint16_t)buf[12] <<  8) |
+                           ((uint16_t)buf[13]      ) ;
+
+    // get IP header fields
+    uint8_t  ip_version  = buf[14];
+    uint8_t  ip_tos      = buf[15];
+    uint16_t ip_length   = ((uint16_t)buf[16] << 8) |
+                           ((uint16_t)buf[17]     ) ;
+
+    uint16_t ip_ident    = ((uint16_t)buf[18] << 8) |
+                           ((uint16_t)buf[19]     ) ;
+    uint16_t ip_offset   = ((uint16_t)buf[20] << 8) |
+                           ((uint16_t)buf[21]     ) ;
+
+    uint8_t  ip_ttl      = buf[22];
+    uint8_t  ip_protocol = buf[23];
+    uint16_t ip_checksum = ((uint16_t)buf[24] << 8) |
+                           ((uint16_t)buf[25]     ) ;
+
+    uint32_t ip_src_addr = ((uint32_t)buf[26] << 24) |
+                           ((uint32_t)buf[27] << 16) |
+                           ((uint32_t)buf[28] <<  8) |
+                           ((uint32_t)buf[29]      ) ;
+
+    uint32_t ip_dst_addr = ((uint32_t)buf[30] << 24) |
+                           ((uint32_t)buf[31] << 16) |
+                           ((uint32_t)buf[32] <<  8) |
+                           ((uint32_t)buf[33]      ) ;
+    
+    // get pointers on TXT0 chdev
+    xptr_t    txt0_xp  = chdev_dir.txt_tx[0];
+    cxy_t     txt0_cxy = GET_CXY( txt0_xp );
+    chdev_t * txt0_ptr = GET_PTR( txt0_xp );
+
+    // get extended pointer on remote TXT0 chdev lock
+    xptr_t  lock_xp = XPTR( txt0_cxy , &txt0_ptr->wait_lock );
+
+    // get TXT0 lock 
+    remote_busylock_acquire( lock_xp );
+
+    if( is_tx )
+    {
+        nolock_printk("\n*** NIC_TX server thread[%x,%x] send packet / cycle %d\n",
+        thread_pid, thread_trdid, cycle );
+    }
+    else
+    {
+        nolock_printk("\n*** NIC_RX server thread[%x,%x] get packet / cycle %d\n",
+        thread_pid, thread_trdid, cycle );
+    }
+
+    nolock_printk("\n***** ETH header *****\n");
+    nolock_printk(" - dst_mac  [6] = %l\n" , eth_dst_mac );
+    nolock_printk(" - src_mac  [6] = %l\n" , eth_src_mac );
+    nolock_printk(" - length   [2] = %d\n" , (uint32_t)eth_length );
+    nolock_printk("***** IP  header *****\n");
+    nolock_printk(" - version  [1] = %x\n" , (uint32_t)ip_version );
+    nolock_printk(" - tos      [1] = %x\n" , (uint32_t)ip_tos );
+    nolock_printk(" - length   [2] = %d\n" , (uint32_t)ip_length );
+    nolock_printk(" - ident    [2] = %x\n" , (uint32_t)ip_ident  );
+    nolock_printk(" - offset   [2] = %x\n" , (uint32_t)ip_offset );
+    nolock_printk(" - ttl      [1] = %x\n" , (uint32_t)ip_ttl );
+    nolock_printk(" - protocol [1] = %x\n" , (uint32_t)ip_protocol );
+    nolock_printk(" - checksum [2] = %x\n" , (uint32_t)ip_checksum );
+    nolock_printk(" - src_addr [4] = %x\n" , (uint32_t)ip_src_addr );
+    nolock_printk(" - dst_addr [4] = %x\n" , (uint32_t)ip_dst_addr );
+
+    // get UDP / TCP fields
+    if ( ip_protocol == PROTOCOL_UDP )
+    {
+        uint16_t udp_src_port = ((uint16_t)buf[34] << 8) |
+                                ((uint16_t)buf[35]     ) ;
+        uint16_t udp_dst_port = ((uint16_t)buf[36] << 8) |
+                                ((uint16_t)buf[37]     ) ;
+
+        nolock_printk("***** UDP header *****\n");
+        nolock_printk(" - src_port [2] = %d\n" , (uint32_t)udp_src_port );
+        nolock_printk(" - dst_port [2] = %d\n" , (uint32_t)udp_dst_port );
+    }
+    else if( ip_protocol == PROTOCOL_TCP )
+    {
+        uint16_t tcp_src_port = ((uint16_t)buf[34] << 8) |
+                                ((uint16_t)buf[35]     ) ;
+        uint16_t tcp_dst_port = ((uint16_t)buf[36] << 8) |
+                                ((uint16_t)buf[37]     ) ;
+
+        uint32_t tcp_seq_num  = ((uint32_t)buf[38] << 24) |
+                                ((uint32_t)buf[39] << 16) |
+                                ((uint32_t)buf[40] <<  8) |
+                                ((uint32_t)buf[41]      ) ;
+
+        uint32_t tcp_ack_num  = ((uint32_t)buf[42] << 24) |
+                                ((uint32_t)buf[43] << 16) |
+                                ((uint32_t)buf[44] <<  8) |
+                                ((uint32_t)buf[45]      ) ;
+
+        uint8_t  tcp_hlen      = buf[46];
+        uint8_t  tcp_flags     = buf[47];
+        uint16_t tcp_window    = ((uint16_t)buf[48] << 8) |
+                                 ((uint16_t)buf[49]     ) ;
+
+        uint16_t tcp_checksum  = ((uint16_t)buf[50] << 8) |
+                                 ((uint16_t)buf[51]     ) ;
+        uint16_t tcp_urgent    = ((uint16_t)buf[52] << 8) |
+                                 ((uint16_t)buf[53]     ) ;
+
+        nolock_printk("***** TCP header *****\n");
+        nolock_printk(" - src_port [2] = %x\n" , (uint32_t)tcp_src_port );
+        nolock_printk(" - dst_port [2] = %x\n" , (uint32_t)tcp_dst_port );
+        nolock_printk(" - seq_num  [4] = %x\n" , (uint32_t)tcp_seq_num );
+        nolock_printk(" - ack_num  [4] = %x\n" , (uint32_t)tcp_ack_num );
+        nolock_printk(" - hlen     [1] = %d\n" , (uint32_t)tcp_hlen );
+        nolock_printk(" - flags    [1] = %x\n" , (uint32_t)tcp_flags );
+        nolock_printk(" - window   [2] = %x\n" , (uint32_t)tcp_window );
+        nolock_printk(" - checksum [2] = %x\n" , (uint32_t)tcp_checksum );
+        nolock_printk(" - urgent   [2] = %x\n" , (uint32_t)tcp_urgent );
+    }
+    else
+    {
+        nolock_printk("!!!!! undefined transport protocol !!!!!\n");
+    }
+
+    // release TXT0 lock 
+    remote_busylock_release( lock_xp );
+
+}  // end dev_nic_packet_display()
+

trunk/kernel/devices/dev_nic.h

@@ -56 +56 @@
  * In this case, the channel index is defined by an hash function computed from the remote
  * IP address and port. This index is computed by the hardware for an RX packet, and is 
- * computed by the kernel for a TX packet, using a specific driver function. TODO ...
+ * computed by the kernel for a TX packet, using a specific driver function. 
  * The 2*N chdevs, and the associated server threads implementing the protocols stack,
  * are distributed in 2*N different clusters.
@@ -63 +63 @@
  * 
  * On the user side, ALMOS-MKH implements the POSIX socket API. 
- * The kernel functions implementing the socket related syscalls are :
- * - dev_nic_socket()    : create a local socket registered in process fd_array[].
- * - dev_nic_bind()      : attach a local IP address and port to a local socket.
- * - dev_nic_listen()    : local server makes a passive open.
- * - dev_nic_connect()   : local client makes an active open to a remote server.
- * - dev_nic_accept()    : local server accept a new remote client.
- * - dev_nic_send()      : send data on a connected socket.
- * - dev_nic_recv()      : receive data on a connected socket.
- * - dev_nic_sendto()    : send a packet to a remote (IP address/port). 
- * - dev_nic_recvfrom()  : receive a paket from a remote (IP address/port).
- * - dev_nic_close()     : close a socket
- *
- * 3) TX stream
- *
- * The internal API between the client threads and the TX server thread defines
- * the 3 following commands: 
- *   . SOCKET_TX_CONNECT : request to execute the 3 steps TCP connection handshake.
- *   . SOCKET_TX_SEND    : send data to a remote socket (UDP or TCP).
- *   . SOCKET_TX_CLOSE   : request to execute the 3 steps TCP close handshake.
- *
- * - These 3 commands are blocking for the client thread that registers the command in the
- *   socket descriptor, blocks on the BLOCKED_IO condition, and deschedules.
- * - The TX server thread is acting as a multiplexer. It scans the list of attached sockets,
- *   to handle all valid commands: one UDP packet or TCP segment per iteration.
- *   It uses the user buffer defined by the client thread, and attached to socket descriptor,
- *   as a retransmission buffer. It blocks and deschedules on the BLOCKED_CLIENT condition,
- *   when there is no more active TX command registered in any socket. It is re-activated 
- *   by the first client thread registering a new TX command in the socket descriptor.
- *   It unblocks a client thread only when a command is fully completed. It signals errors
- *   to the client thread using the tx_error field in socket descriptor.
- *
- * 4) RX stream
- *
- * The communication between the RX server thread and the client threads expecting data
- * is done through receive buffers (one private buffer per socket) that are handled
- * as single-writer / single reader-FIFOs, called rx_buf. 
- * - The RX server thread is acting as a demultiplexor: it handle one TCP segment or UDP
- *   packet per iteration, and register the data in the rx_buf of the socket matching
- *   the packet. It simply discard all packets that does not match a registered socket.
- *   When a client thread is registered in the socket descriptor, the RX server thread
- *   unblocks this client thread as soon as there is data available in rx_buf.
- *   It blocks and deschedules on the BLOCKED_ISR condition when there is no more packets
- *   in the NIC_RX queue. It is unblocked by the hardware ISR.
- * - The client thread simply access the rx_buf attached to socket descriptor, and consumes
- *   the available data when the rx_buf is non empty. It blocks on the BLOCKED_IO condition,
- *   and deschedules when the rx_buf is empty. 
- *
- * 5) R2T queue
- *
- * To implement the TCP "3 steps handshake" protocol, the RX server thread can directly
- * request the associated TX server thread to send control packets in  the TX stream, 
- * using a dedicate R2T (RX to TX) FIFO stored in the socket descriptor.
- *
- * 6) NIC driver API
- *
- * The generic NIC device "driver" API defines the following commands to the NIC driver:
- * - READABLE : returns true if at least one RX paquet is available in RX queue.
- * - WRITABLE : returns true if at least one empty slot is available in TX queue.
- * - READ     : consume one packet from the RX queue.
- * - WRITE    : produce one packet to the TX queue.
+ * The following kernel functions implement the socket related syscalls :
+ * - socket_build()     : create a local socket registered in process fd_array[].
+ * - socket_bind()      : attach a local IP address and port to a local socket.
+ * - socket_listen()    : local server makes a passive open.
+ * - socket_connect()   : local client makes an active open to a remote server.
+ * - socket_accept()    : local server accept a new remote client.
+ * - socket_send()      : send data on a connected socket.
+ * - socket_recv()      : receive data on a connected socket.
+ * - socket_sendto()    : send a packet to a remote (IP address/port). 
+ * - socket_recvfrom()  : receive a paket from a remote (IP address/port).
+ *
+ * 3) NIC TX and NIC_RX server threads
+ *
+ * The dev_nic_tx_server() & dev_nic_rx_server() functions defined below execute 
+ * the user commands stored in the sockets to implement the [ETH / IP / TCP or UDP] 
+ * protocols stack, as defined in the <ksocket.c> and <ksocket.h> files.
+ *
+ * 4) NIC driver API
+ *
+ * The generic NIC device "driver" API defines the following commands, used by the
+ * NIC_TX and NIC_RX server threads, running in the cluster containing the relevant chdev,
+ * to access the NIC_TX and NIC_RX packets queues:
+ *
+ * - READ     : consume one packet from the NIC_RX queue.
+ * - WRITE    : produce one packet to the NIC_TX queue.
+ *
  * All RX or TX paquets are sent or received in standard 2 Kbytes kernel buffers,
  * that are dynamically allocated by the protocols stack. 
- *
  * The actual TX an RX queues structures depends on the hardware NIC implementation,
  * and are defined in the HAL specific driver code. 
+ *
+ * Moreover, the generic NIC device "driver" API defines the following commands,
+ * used directly by a client thread running in any cluster, to access the NIC device
+ * configuration or status registers:
+ *
+ * - GET_KEY      : get channel index from remote IP address and port 
+ * - SET_RUN      : activate/desactivate one channel
+ * - GET_INSTRU   : get one instrumentation counter value
+ * - CLEAR_INSTRU : reset all instrumentation counters
  *
  * WARNING: the WTI mailboxes used by the driver ro receive events from the hardware
@@ -140 +114 @@
 struct chdev_s;
 
-/******************************************************************************************
- *   Various constants used by the Protocols stack
- *****************************************************************************************/
-
-#define SRC_MAC_54             0x54
-#define SRC_MAC_32             0x32
-#define SRC_MAC_10             0x10
-#define DST_MAC_54             0x54
-#define DST_MAC_32             0x32
-#define DST_MAC_10             0x10
+/*****************************************************************************************
+ *   Various constants used by the protocols stack
+ ****************************************************************************************/
+
+#define SRC_MAC_5              0x66         // This is a temporary short-cut for debug
+#define SRC_MAC_4              0x55
+#define SRC_MAC_3              0x44
+#define SRC_MAC_2              0x33
+#define SRC_MAC_1              0x22
+#define SRC_MAC_0              0x11
+
+#define DST_MAC_5              0x66         // This is a temporary short-cut for debug
+#define DST_MAC_4              0x55
+#define DST_MAC_3              0x44
+#define DST_MAC_2              0x33
+#define DST_MAC_1              0x22
+#define DST_MAC_0              0x11
 
 #define TCP_HEAD_LEN           20
@@ -159 +140 @@
 #define PROTOCOL_TCP           0x06
 
-#define TCP_ISS                0x10000
-
-#define PAYLOAD_MAX_LEN        1500         // max payload for and UDP packet or a TCP segment
+#define TCP_ISS_CLIENT         0x10000      // initial sequence number for TCP client
+#define TCP_ISS_SERVER         0x20000      // initial sequence number for TCP server
+#define TCP_MAX_WINDOW         0xFFFFF      // initial TCP send window
+
+#define PAYLOAD_MAX_LEN        1500         // max length for an UDP packet / TCP segment
 
 #define TCP_FLAG_FIN           0x01
@@ -172 +155 @@
 #define NIC_RX_BUF_SIZE        0x100000     // 1 Mbytes
 #define NIC_R2T_QUEUE_SIZE     0x64         // smallest KCM size
-#define NIC_CRQ_QUEUE_SIZE     0x8          // 8 * sizeof(sockaddr_t) = smallest KCM size
-#define NIC_PKT_MAX_SIZE       1500         // for Ethernet
-#define NIC_KERNEL_BUF_SIZE    2000         // for on ETH/IP/TCP packet
+#define NIC_CRQ_QUEUE_SIZE     0x8          // actual size is 8 * sizeof(sockaddr_t)
+#define NIC_KERNEL_BUF_SIZE    0x800        // 2 Kbytes for one ETH/IP/TCP packet
 
 /*****************************************************************************************
- * This defines the extension for the generic NIC device.
- * The actual queue descriptor depends on the implementation.
- *
- * WARNING : for all NIC_TX and NIC_RX chdevs, the xlist rooted in in the chdev
- *           ("wait_root" and "wait_lock" fields) is actually a list of sockets.
+ * This structure defines the specific chdev extension for NIC device:
+ * - queue : local pointer on the memory mapped queue of TX or RX packets, used
+ *   by the NIC driver to move packets to/from the NIC hardware. The actual descriptor
+ *   depends on the NIC implementation.
+ * - root  : root of an xlist of sockets that are in the LISTEN state, waiting one or
+ *   several TCP connection requests from remote processes. It is only used by the
+ *   NIC_RX server thread attached to a NIC_RX chdev. 
+ * - lock  : lock protecting concurrent access to the litening sockets list.
  ****************************************************************************************/
 
 typedef struct nic_extend_s
 {
-    void         * queue;       /*! local pointer on NIC queue descriptor (RX or TX)    */
+    void            * queue;    /*! pointer on NIC packets queue descriptor (RX or TX)  */
+    xlist_entry_t     root;     /*! root of listening sockets list (only used in RX[0]) */
+    remote_busylock_t lock;     /*! lock protecting this list  (only used in RX[0]      */
 }
 nic_extend_t;
@@ -204 +191 @@
 /****************************************************************************************
  * This defines the (implementation independant) commands to access the NIC hardware.
- * These commands are registered by the NIC_TX and NIC_RX server threads in the
- * server thread descriptor, to be used by the NIC driver. 
- * The buffer is always a 2K bytes kernel buffer, containing an Ethernet packet.
+ * There is two types of commands
+ * - The first 2 commands are used by the NIC_TX and NIC_RX server threads, and stored
+ *   in the server thread descriptor, to access the NIC_RX & NIC_TX packet queues.
+ *   The buffer is always a 2K bytes kernel buffer, containing an Ethernet packet.
+ * - The next 4 synchronous commands are used by the client th, and stored in the 
+ *   client thread descriptor, to directly access the NIC registers. 
  ****************************************************************************************/
 
 typedef enum nic_cmd_e
 {
-    NIC_CMD_WRITABLE  = 10,   /*! test TX queue not full (for a given packet length)    */
-    NIC_CMD_WRITE     = 11,   /*! put one (given length) packet to TX queue             */
-    NIC_CMD_READABLE  = 12,   /*! test RX queue not empty (for any packet length)       */
-    NIC_CMD_READ      = 13,   /*! get one (any length) packet from RX queue             */
+    NIC_CMD_WRITE        = 10,  /*! put one (given length) packet to TX queue           */
+    NIC_CMD_READ         = 11,  /*! get one (any length) packet from RX queue           */
+
+    NIC_CMD_GET_KEY      = 20,  /*! return channel index from IP address and port       */ 
+    NIC_CMD_SET_RUN      = 21,  /*! enable/disable one NIC channel                      */
+    NIC_CMD_GET_INSTRU   = 22,  /*! return one intrumentation register value            */
+    NIC_CMD_CLEAR_INSTRU = 23,  /*! reset all instrumentation registers                 */
 }
 nic_cmd_t;
@@ -222 +215 @@
     xptr_t      dev_xp;       /*! extended pointer on NIC chdev descriptor              */
     nic_cmd_t   type;         /*! command type                                          */
-    uint8_t   * buffer;       /*! local pointer on buffer (kernel or user space)        */  
+    uint8_t   * buffer;       /*! local pointer on kernel buffer                        */  
     uint32_t    length;       /*! number of bytes in buffer                             */
     uint32_t    status;       /*! return value (depends on command type)                */
@@ -228 +221 @@
 }
 nic_command_t;
-
-/***************************************************************************************** 
- * This structure defines a socket descriptor. In order to parallelize the transfers,
- * the set of all registered sockets is split in several subsets.
- * The number of subsets is the number of  NIC channels. 
- * The distribution key is computed from the (remote_addr/remote_port) couple.
- * This computation is done by the NIC hardware for RX packets, 
- * and by the dev_nic_connect() function for the TX packets.
- *
- * A socket is attached to the NIC_TX[channel] & NIC_RX[channel] chdevs.
- * Each socket descriptor allows the TX and TX server threads to access various buffers:
- * - the user "send" buffer contains the data to be send by the TX server thread.
- * - the kernel "receive" buffer contains the data received by the RX server thread.
- * - the kernel "r2t" buffer allows the RX server thread to make direct requests
- *   to the associated TX server (to implement the TCP 3 steps handshake).
- *
- * The synchronisation mechanism between the clients threads and the servers threads
- * is different for TX and RX transfers:
- *
- * 1) For a TX transfer, it can exist only one client thread for a given socket,
- *    the transfer is always initiated by the local process, and all TX commands
- *    (CONNECT/SEND/CLOSE) are blocking for the client thread. The user buffer is
- *    used by TCP to handle retransmissions when required.in case of re
- *    The client thread registers the command in the thread descriptor, registers itself
- *    in the socket descriptor, unblocks the TX server thread from the BLOCKED_CLIENT 
- *    condition, blocks itself on the BLOCKED_IO condition, and deschedules. 
- *    When the command is completed, the TX server thread unblocks the client thread.
- *    The TX server blocks itself on the BLOCKED_CLIENT condition, when there is no
- *    pending commands and the R2T queue is empty. It is unblocked when a client
- *    register a new command, or when the TX server thread register a mew request
- *    in the R2T queue.
- *    The tx_valid flip-flop is SET by the client thread to signal a valid command. 
- *    It is RESET by the server thread when the command is completed: For a SEND, 
- *    all bytes have been sent (UDP) or acknowledged (TCP).
- *
- * 2) For an RX transfer, it can exist only one client thread for a given socket,
- *    but the transfer is initiated by the remote process, and the  RECV command
- *    is not really blocking: the data can arrive before the local RECV command is
- *    executed, and the server thread does not wait to receive all requested data
- *    to deliver data to client thread. Therefore each socket contains a receive
- *    buffer (rx_buf) handled as a single-writer/single-reader fifo.
- *    The client thread consumes data from the rx_buf when possible. It blocks on the
- *    BLOCKED_IO condition and deschedules when the rx_buf is empty.
- *    It is unblocked by the RX server thread when new data is available in the rx_buf.
- *    The RX server blocks itself on the BLOCKED_ISR condition When the NIC_RX packets
- *    queue is empty. It is unblocked by the hardware when new packets are available.
- * 
- * Note : the socket domains and types are defined in the "shared_socket.h" file.
- ****************************************************************************************/
-
-/******************************************************************************************
- * This function returns a printable string for a given NIC command <type>.
- ******************************************************************************************
- * @ type    : NIC command type
- *****************************************************************************************/
-char * nic_cmd_str( uint32_t type );
-   
-/******************************************************************************************
- * This function returns a printable string for a given socket <state>.
- ******************************************************************************************
- * @ state    : socket state
- *****************************************************************************************/
-char * socket_state_str( uint32_t state );
 
 /******************************************************************************************
@@ -299 +229 @@
  * device and the specific data structures when required.
  * It creates the associated server thread and allocates a WTI from local ICU.
- * For a TX_NIC chedv, it allocates and initializes the R2T waiting queue used by the 
- * NIC_RX[channel] server to send direct requests to the NIC_TX[channel] server.
+ * For a TX_NIC chedv, it allocates and initializes the R2T queue used by the 
+ * NIC_RX[channel] server to send direct requests to the NIC_TX[channel] server,
+ * and the CRQ queue used to register connection requests.
  * It must de executed by a local thread.
+ * For NIC_TX and NIC_RX chdevs, the "wait_root" field is actually a list of sockets.
  ******************************************************************************************
  * @ chdev    : local pointer on NIC chdev descriptor.
@@ -307 +239 @@
 void dev_nic_init( struct chdev_s * chdev );
 
-
-/* functions implementing the socket API */
-
-/****************************************************************************************
- * This function implements the socket() syscall.
- * This function allocates and intializes in the calling thread cluster:
- * - a new socket descriptor, defined by the <domain> and <type> arguments,
- * - a new file descriptor, associated to this socket,
- * It registers the file descriptor in the reference process fd_array[], set 
- * the socket state to IDLE, and returns the <fdid> value.
- ****************************************************************************************
- * @ domain  : [in] socket protocol family (AF_UNIX / AF_INET)
- * @ type    : [in] socket type (SOCK_DGRAM / SOCK_STREAM).
- * @ return a file descriptor <fdid> if success / return -1 if failure.
-***************************************************************************************/
-int dev_nic_socket( uint32_t   domain,
-                    uint32_t   type );
-
-/****************************************************************************************
- * This function implements the bind() syscall.
- * It initializes the  "local_addr" and "local_port" fields in the socket
- * descriptor identified by the <fdid> argument and set the socket state to BOUND.
- * It can be called by a thread running in any cluster.
- ****************************************************************************************
- * @ fdid      : [in] file descriptor identifying the socket.
- * @ addr      : [in] local IP address.
- * @ port      : [in] local port.
- * @ return 0 if success / return -1 if failure.
- ***************************************************************************************/
-int dev_nic_bind( uint32_t fdid,
-                  uint32_t addr,
-                  uint16_t port );
-
-/****************************************************************************************
- * This function implements the listen() syscall().
- * It is called by a (local) server process to specify the max size of the queue
- * registering the (remote) client process connections, and set the socket identified
- * by the <fdid> argument to LISTEN state. It applies only to sockets of type TCP.
- * It can be called by a thread running in any cluster.
- * TODO handle the <max_pending> argument...
- ****************************************************************************************
- * @ fdid        : [in] file descriptor identifying the local server socket.
- * @ max_pending : [in] max number of accepted remote client connections.
- ***************************************************************************************/
-int dev_nic_listen( uint32_t fdid,
-                    uint32_t max_pending );
-
-/****************************************************************************************
- * This function implements the connect() syscall.
- * It is used by a (local) client process to connect a local socket identified by 
- * the <fdid> argument, to a remote socket identified by the <remote_addr> and 
- * <remote_port> arguments. It can be used for both  UDP and TCP sockets. 
- * It computes the nic_channel index from <remote_addr> and <remote_port> values,
- * and initializes "remote_addr","remote_port", "nic_channel" in local socket.
- * It registers the socket in the two lists of clients rooted in the NIC_RX[channel] 
- * and NIC_TX[channel] chdevs.  It can be called by a thread running in any cluster.
- * WARNING : the clients are the socket descriptors, and NOT the threads descriptors.
- ****************************************************************************************
- * Implementation Note:
- * - For a TCP socket, it updates the "remote_addr", "remote_port", "nic_channel" fields
- *   in the socket descriptor defined by the <fdid> argument, and register this socket,
- *   in the lists of sockets attached to the NIC_TX and NIC_RX chdevs.
- *   Then, it registers a CONNECT command in the "nic_cmd" field ot the client thread
- *   descriptor to request the NIC_TX server thread to execute the 3 steps handshake,
- *   and updates the "tx_client" field in the socket descriptor. It unblocks the NIC_TX 
- *   server thread, blocks on the THREAD_BLOCKED_IO condition and deschedules.
- * - For an UDP socket, it simply updates "remote_addr", "remote_port", "nic_channel"
- *   in the socket descriptor defined by the <fdid> argument, and register this socket,
- *   in the lists of sockets attached to the NIC_TX and NIC_RX chdevs.
- *   Then, it set the socket state to CONNECT, without unblocking the NIC_TX server 
- *   thread, and without blocking itself.
- * TODO : the nic_channel index computation must be done by a driver specific function.
- ****************************************************************************************
- * @ fdid          : [in] file descriptor identifying the socket.
- * @ remote_addr   : [in] remote IP address.
- * @ remote_port   : [in] remote port.
- * @ return 0 if success / return -1 if failure.
- ***************************************************************************************/
-int dev_nic_connect( uint32_t  fdid,
-                     uint32_t  remote_addr,
-                     uint16_t  remote_port );
-
-/****************************************************************************************
- * This function implements the accept() syscall().
- * It is executed by a server process, waiting for one (or several) client process(es)
- * requesting a connection on a socket identified by the <fdid> argument.
- * This socket was previouly created with socket(), bound to a local address with bind(), 
- * and is listening for connections after a listen().
- * This function extracts the first connection request on the CRQQ queue of pending
- * requests, creates a new socket with the same properties as the existing socket,
- * and allocates a new file descriptor for this new socket.
- * If no pending connections are present on the queue, it blocks the caller until a 
- * connection is present. 
- * The new socket cannot accept more connections, but the original socket remains open.
- * It returns the new socket <fdid>, and register in the <address> an <port> arguments
- * the remote client IP address & port. It applies only to sockets of type SOCK_STREAM.
- ****************************************************************************************
- * @ fdid         : [in] file descriptor identifying the listening socket.
- * @ address      : [out] server IP address.
- * @ port         : [out] server port address length in bytes.
- * @ return the new socket <fdid> if success / return -1 if failure
- ***************************************************************************************/
-int dev_nic_accept( uint32_t   fdid,
-                    uint32_t * address,
-                    uint16_t * port );
-
-/****************************************************************************************
- * This blocking function implements the send() syscall.
- * It is used to send data stored in the user buffer, identified the <u_buf> and <length>
- * arguments, to a connected (TCP or UDP) socket, identified by the <fdid> argument.
- * The work is actually done by the NIC_TX server thread, and the synchronisation
- * between the client and the server threads uses the "rx_valid" set/reset flip-flop:
- * The client thread registers itself in the socket descriptor, registers in the queue 
- * rooted in the NIC_TX[index] chdev, set "rx_valid", unblocks the server thread, and 
- * finally blocks on THREAD_BLOCKED_IO, and deschedules. 
- * When the TX server thread completes the command (all data has been sent for an UDP
- * socket, or acknowledeged for a TCP socket), the server thread reset "rx_valid" and
- * unblocks the client thread.
- * This function can be called by a thread running in any cluster.
- * WARNING : This implementation does not support several concurent SEND/SENDTO commands
- * on the same socket, as only one TX thread can register in a given socket.
- ****************************************************************************************
- * @ fdid      : [in] file descriptor identifying the socket.
- * @ u_buf     : [in] pointer on buffer containing packet in user space.
- * @ length    : [in] packet size in bytes.
- * @ return number of sent bytes if success / return -1 if failure.
- ***************************************************************************************/
-int dev_nic_send( uint32_t    fdid,
-                  uint8_t   * u_buf,
-                  uint32_t    length );
-
-/****************************************************************************************
- * This blocking function implements the sendto() syscall. 
- * It registers the <remote_addr> and <remote_port> arguments in the local socket
- * descriptor, and does the same thing as the dev_nic_send() function above, 
- * but can be called  on an unconnected UDP socket.
- ****************************************************************************************
- * @ fdid        : [in] file descriptor identifying the socket.
- * @ u_buf       : [in] pointer on buffer containing packet in user space.
- * @ length      : [in] packet size in bytes.
- * @ remote_addr : [in] destination IP address.
- * @ remote_port : [in] destination port.
- * @ return number of sent bytes if success / return -1 if failure.
- ***************************************************************************************/
-int dev_nic_sendto( uint32_t    fdid,
-                    uint8_t   * u_buf,
-                    uint32_t    length,
-                    uint32_t    remote_addr,
-                    uint32_t    remote_port );
-
-/****************************************************************************************
- * This blocking function implements the recv() syscall.
- * It is used to receive data that has been stored by the NIC_RX server thread in the
- * rx_buf of a connected (TCP or UDP) socket, identified by the <fdid> argument.
- * The synchronisation between the client and the server threads uses the "rx_valid"
- * set/reset flip-flop: If "rx_valid" is set, the client simply moves the available
- * data from the "rx_buf" to the user buffer identified by the <u_buf> and <length>
- * arguments, and reset the "rx_valid" flip_flop. If "rx_valid" is not set, the client
- * thread register itself in the socket descriptor, registers in the clients queue rooted
- * in the NIC_RX[index] chdev, and finally blocks on THREAD_BLOCKED_IO, and deschedules. 
- * The client thread is re-activated by the RX server, that set the "rx_valid" flip-flop 
- * as soon as data is available in the "rcv_buf" (can be less than the user buffer size).
- * This  function can be called by a thread running in any cluster.
- * WARNING : This implementation does not support several concurent RECV/RECVFROM 
- * commands on the same socket, as only one RX thread can register in a given socket.
- ****************************************************************************************
- * @ fdid      : [in] file descriptor identifying the socket.
- * @ u_buf     : [in] pointer on buffer in user space.
- * @ length    : [in] buffer size in bytes.
- * @ return number of received bytes if success / return -1 if failure.
- ***************************************************************************************/
-int dev_nic_recv( uint32_t    fdid,
-                  uint8_t   * u_buf,
-                  uint32_t    length );
-
-/****************************************************************************************
- * This blocking function implements the recvfrom() syscall.
- * It registers the <remote_addr> and <remote_port> arguments in the local socket
- * descriptor, and does the same thing as the dev_nic_recv() function above, 
- * but can be called  on an unconnected UDP socket.
- ****************************************************************************************
- * @ fdid        : [in] file descriptor identifying the socket.
- * @ u_buf       : [in] pointer on buffer containing packet in user space.
- * @ length      : [in] packet size in bytes.
- * @ remote_addr : [in] destination IP address.
- * @ remote_port : [in] destination port.
- * @ return number of received bytes if success / return -1 if failure.
- ***************************************************************************************/
-int dev_nic_recvfrom( uint32_t    fdid,
-                      uint8_t   * u_buf,
-                      uint32_t    length,
-                      uint32_t    remote_addr,
-                      uint32_t    remote_port );
-
-
-/*  Instrumentation functions */
-
+/* Functions directly called by a client thread in any cluster */
+ 
+/******************************************************************************************
+ * This function compute a channel index in range [0,nic_channels[ from the remote IP
+ * address <addr> and <port>, by calling the relevant driver command.
+ ******************************************************************************************
+ * @ addr     : [in] IP address.
+ * @ port     : [in] TCP/UDP port.
+ * @ return the selected channel index
+ *****************************************************************************************/
+uint32_t dev_nic_get_key( uint32_t addr,
+                          uint16_t port );
+
+/******************************************************************************************
+ * This function activate / de-activate a NIC channel DMA engine identified by the
+ * <channel> argument, as defined by the <run> argument.
+ ******************************************************************************************
+ * @ channel  : [in] NIC channel index.
+ * @ run      : [in] activate if non-zero / desactivate if zero.
+ * @ return 0 if success / return -1 if error.
+ *****************************************************************************************/
+error_t dev_nic_set_run( uint32_t channel,
+                         uint32_t run );
 
 /******************************************************************************************
  * This instrumentation function displays on the TXT0 kernel terminal the content
  * of the instrumentation registers contained in the NIC device.
- *****************************************************************************************/
-void dev_nic_print_stats( void );
+ ******************************************************************************************
+ * @ return 0 if success / return -1 if error.
+ *****************************************************************************************/
+error_t dev_nic_get_instru( void );
 
 /******************************************************************************************
  * This instrumentation function reset all instrumentation registers contained
  * in the NIC device.
- *****************************************************************************************/
-void dev_nic_clear_stats( void );
-
+ ******************************************************************************************
+ * @ return 0 if success / return -1 if error.
+ *****************************************************************************************/
+error_t dev_nic_clear_instru( void );
 
 /* Functions executed by the TX and RX server threads */ 
@@ -532 +293 @@
  * When the TX client threads queue is empty, it blocks on THREAD_BLOCKED_CLIENT
  * condition and deschedules. It is re-activated by a client thread registering a command.
+ * When the NIC_TX packet queue is full, it blocks on the THREAD_BLOCKED_ISR condition
+ * and deschedules. It is reactivated by the NIC_TX DMA engine.
  ******************************************************************************************
  * Implementation note:
@@ -556 +319 @@
  * requests to the TX server, using the R2T queue attached to the involved socket. 
  * It blocks on the THREAD_BLOCKED_ISR condition and deschedules when the NIC_RX_QUEUE
- * is empty. It is re-activated by the NIC_RX_ISR, when the queue becomes non empty.
+ * is empty, and is re-activated by the NIC_RX_ISR, when the queue becomes non empty.
  ******************************************************************************************
  * Implementation note:
@@ -570 +333 @@
 void dev_nic_rx_server( struct chdev_s * chdev );
 
+/******************************************************************************************
+ * This function displays all the fields of an ETH/IP/TCP segment or ETH/IP/UDP packet. 
+ ******************************************************************************************
+ * @ is_tx   : [in] sent packet if true / received packet if false.
+ * @ pid     : [in] process identifier.
+ * @ trdid   : [in] thread identifier.
+ * @ cycle   : [in] date (number of cycles).
+ * @ buf     : [in] local pointer on kernel buffer containing the packet.
+ *****************************************************************************************/
+void dev_nic_packet_display( bool_t    is_tx,
+                             pid_t     pid,
+                             trdid_t   trdid,
+                             uint32_t  cycle,
+                             uint8_t * buf );
+
 #endif  /* _DEV_NIC_H */

trunk/kernel/devices/dev_txt.c

@@ -74 +74 @@
     bool_t    is_rx   = txt->is_rx;
 
-    assert( (pic_xp != XPTR_NULL) || (channel == 0) ,
-            "PIC not initialised before TXT" );
+assert( (pic_xp != XPTR_NULL) || (channel == 0) ,
+"PIC not initialised before TXT" );
 
     // set chdev name