Changeset 116

Timestamp:

06/28/2007 11:21:55 AM (5 years ago)

Author:

ayb

Message:

 

Location:

nano-RK/projects/network_stack

Files:

• BufferManager.c (modified) (7 diffs)
• BufferManager.h (modified) (4 diffs)
• NWErrorCodes.h (modified) (1 diff)
• TransportLayerUDP.c (modified) (40 diffs)
• TransportLayerUDP.h (modified) (10 diffs)
• makefile (modified) (1 diff)

nano-RK/projects/network_stack/BufferManager.c

@@ -732 +732 @@
 }
 /*************************************************************************************************/
-ReceiveBufferUDP* remove_rx_pq(int8_t port)
+ReceiveBufferUDP* remove_rx_pq(ReceiveBufferManager *rbm)
 {
         // The remove is always done from the head of the queue since its a priority queue      
@@ -739 +739 @@
         //enter_cr(bm_sem, "remove_rx_pq()");
                         
-        if(rx_buf_mgr[port].head_pq == NULL)    // no more queued segments
+        if(rbm -> head_pq == NULL)      // no more queued segments
         {
                 //leave_cr(bm_sem, "remove_rx_pq()");
@@ -745 +745 @@
         }
                 
-        if(rx_buf_mgr[port].head_pq == rx_buf_mgr[port].tail_pq)        // only one buffer in queue 
-                rx_buf_mgr[port].tail_pq = NULL;
-                
-        ptr = rx_buf_mgr[port].head_pq;
-        
-        rx_buf_mgr[port].head_pq = rx_buf_mgr[port].head_pq -> next;
+        if(rbm -> head_pq == rbm -> tail_pq)    // only one buffer in queue 
+                rbm -> tail_pq = NULL;
+                
+        ptr = rbm -> head_pq;
+        
+        rbm -> head_pq = rbm -> head_pq -> next;
                 
         //leave_cr(bm_sem, "remove_rx_pq()");   
@@ -756 +756 @@
 }
 /*************************************************************************************************/
-
-void insert_rx_fq(ReceiveBufferUDP *buf, int8_t port, int8_t status)
-{
-        //enter_cr(bm_sem, "insert_rx_fq()");   
-                
+void insert_rx_fq(ReceiveBufferUDP *buf, int8_t index, int8_t status)
+{
         // the insert is always done at the tail of the queue 
-        if(rx_buf_mgr[port].head_fq == NULL)    // the free queue is empty 
-        {
-                rx_buf_mgr[port].head_fq = rx_buf_mgr[port].tail_fq = buf;
+        if(rx_buf_mgr[index].head_fq == NULL)   // the free queue is empty 
+        {
+                rx_buf_mgr[index].head_fq = rx_buf_mgr[index].tail_fq = buf;
                 buf -> next = NULL;
         }       
         else
         {
-                rx_buf_mgr[port].tail_fq -> next = buf;
+                rx_buf_mgr[index].tail_fq -> next = buf;
                 buf -> next = NULL;
-                rx_buf_mgr[port].tail_fq = buf;
+                rx_buf_mgr[index].tail_fq = buf;
         }
 
         if(status == EMPTY)     // this function was called from bind() / setReceiveQueueSize()
         {
-                rx_buf_mgr[port].countFree++;
+                rx_buf_mgr[index].countFree++;
                 buf -> status = EMPTY;
         }
         
-        //leave_cr(bm_sem, "insert_rx_fq()");   
         return;
 }
 
 /***************************************************************************************************/
-ReceiveBufferUDP* remove_rx_fq(uint8_t port, int8_t status)
+ReceiveBufferUDP* remove_rx_fq(ReceiveBufferManager *rbm, int8_t status)
 {
         // This function removes the next receive buffer from the free queue having a given status      
@@ -791 +787 @@
         ReceiveBufferUDP *prev = NULL;
         
-        if(rx_buf_mgr[port].head_fq == NULL)    // no buffers remaining in free queue   
+        if(rbm -> head_fq == NULL)      // no buffers remaining in free queue   
                 return NULL;
                 
-        ptr = rx_buf_mgr[port].head_fq;
+        ptr = rbm -> head_fq;
         while(ptr != NULL)
         {
@@ -812 +808 @@
         if(prev == NULL)        // the EMPTY / FULL buffer is at the head of the queue
         {
-                if(rx_buf_mgr[port].head_fq == rx_buf_mgr[port].tail_fq)        // only one buffer in free queue
-                        rx_buf_mgr[port].tail_fq = NULL;
-                        
-                rx_buf_mgr[port].head_fq = rx_buf_mgr[port].head_fq -> next;
+                if(rbm -> head_fq == rbm -> tail_fq)    // only one buffer in free queue
+                        rbm -> tail_fq = NULL;
+                        
+                rbm -> head_fq = rbm -> head_fq -> next;
                 if(status == EMPTY)
-                        rx_buf_mgr[port].countFree--;
+                        (rbm -> countFree)--;
                 return ptr;
         }
@@ -824 +820 @@
         prev -> next = ptr -> next;
         if(status == EMPTY)
-                rx_buf_mgr[port].countFree--;
+                (rbm -> countFree)--;
         return ptr;
 }

nano-RK/projects/network_stack/BufferManager.h

@@ -36 +36 @@
 
 // priority level of task ....SHIFT this to Anthony's code 
-#define MAX_TASK_PRIORITY 10  
+#define MAX_TASK_PRIORITY 127  
  
 // priority levels of messages 
@@ -59 +59 @@
 typedef struct
 {
-        int8_t pid;                                                             // pid of task associated with the port 
+        int8_t pid;                                                             // pid of the process holding this receive buffer manager       
+        Port *port;                                                             // pointer to the port information  
         ReceiveBufferUDP *head_fq;                      // pointer to head of free queue (EMPTY or FULL buffers)
         ReceiveBufferUDP *tail_fq;                      // pointer to tail of free queue (EMPTY or FULL buffers) 
@@ -66 +67 @@
         int8_t countTotal;                                      // total number of buffers reserved for this port 
         int8_t countFree;                                               // number of buffers EMPTY at any time 
-        nrk_sig_t seg_arrived_signal;   // is sent by network layer when a segment is inserted
-                                                                                                // into the port queue 
+        
 }ReceiveBufferManager;                                  // one for every port in the system 
 
@@ -90 +90 @@
 }TransmitBufferManager;
 
-typedef struct 
-{
-        nrk_sig_t send_done_signal;
-}SendDoneSignal;
-
 /***************************** FUNCTION PROTOTYPES ************************************/
 

nano-RK/projects/network_stack/NWErrorCodes.h

@@ -19 +19 @@
 #define NO_TX_BUFFERS_AVAILABLE 12 
 #define SOCKET_TIMEOUT 13 
+#define NO_PORT_ELEMENT_AVAILABLE 14 
+#define NO_RBM_ELEMENT_AVAILABLE 15 
 
 #endif 

nano-RK/projects/network_stack/TransportLayerUDP.c

@@ -9 +9 @@
 /****************** Global data structures required for port and socket management ***************/
 
-Socket sock[MAX_PORTS];                         // array to store available socket descriptors 0 - (MAX_PORTS - 1) 
-                                                                                        // a pid value of -1 (INVALID_PID) indicates that it is unassigned 
-                                                                                        
-uint32_t ports;                                         // a 32-bit number indicating which port numbers are free or taken
-                                                                                        // a value of 1 at bit position 'x' indicates that port 'x' has been taken
-                                                                                        // a value of 0 at bit position 'x' indicates that port 'x' is available
-                                                                                        
+Socket sock[MAX_PORTS];                         // array to store available socket descriptors 0 - (MAX_PORTS - 1)
+
+Port ports[MAX_PORTS];                          // array to store information about each port
+
 int8_t tlayer_init_done;                        // flag to indicate whether initialization has been done correctly 
 
@@ -31 +28 @@
 extern TransmitBuffer tx_buf[];
 extern TransmitBufferManager tx_buf_mgr;
-extern SendDoneSignal sd_sig[];
 extern nrk_sem_t *bm_sem;
 
@@ -45 +41 @@
 extern void pack_TL_UDP_header(uint8_t*, Transport_Segment_UDP*);
 
-// From Debug.c 
-extern void go_into_panic(int8_t *);
-
 /************************** Function definitions ***************************************************/
 void initialise_transport_layer_udp()
 {
         int8_t i;       // loop index 
-        // make all the socket descriptors unassigned 
+        
+        // initialise the socket descriptors and port elements 
         for(i = 0; i < MAX_PORTS; i++)
         {
-                sock[i].pid = INVALID_PID;
-                sock[i].port = INVALID_PORT;
-                sock[i].timeout.secs = 0;               // indicates no timeout 
-                sock[i].timeout.nano_secs = 0; 
-        }
-        // make all the ports available 
-        ports = 0;
-        
-        tl_sem = nrk_sem_create(1,MAX_TASK_PRIORITY);   // create the mutex  
+                sock[i].port = NULL;                                    // indicates the absence of socket-port mapping
+                sock[i].rbm = NULL;                                     // indicates the absence of socket-port mapping 
+                sock[i].pid = INVALID_PID;                      // indicates an unassigned socket descriptor            
+                sock[i].timeout.secs = 0;                       // indicates no timeout 
+                sock[i].timeout.nano_secs = 0;  // indicates no timeout
+                
+                ports[i].pno = INVALID_PORT;            // indicates an unassigned port number 
+        }
+        
+        // create the mutex of priority ceiling equal to MAX_TASK_PRIORITY      
+        tl_sem = nrk_sem_create(1,MAX_TASK_PRIORITY);   
         if(tl_sem == NULL)
         {
@@ -71 +67 @@
                         nrk_kprintf(PSTR("initialise_transport_layer_udp(): Error creating the semaphore\r\n"));
         }       
+        
+        // check to see if the user has given a valid number for MAX_PORTS
+        if(MAX_PORTS > 127)     // a node cannot hold more than 127 ports 
+        {
+                nrk_int_disable();
+                nrk_led_set(RED_LED);
+                while(1)
+                        nrk_kprintf(PSTR("initialise_transport_layer_udp(): Error in value of MAX_PORTS\r\n"))l
+        }
+        
         // set the init_done flag 
         tlayer_init_done = 1;
@@ -77 +83 @@
 /**************************************************************************************************/
 int8_t get_next_available_socket()
-// private function. This returns the index of the next available socket descriptor or NRK_ERROR if
-// none are available 
 {
         int8_t i;               // loop index
@@ -88 +92 @@
                         return i;
         }
+        
         _nrk_errno_set(NO_SOCKET_DESC_AVAILABLE);       
-        
         return NRK_ERROR;
 }
@@ -118 +122 @@
                                 }
                                 break;
-                
+                                
+                case SOCK_IPC:
+                                result = get_next_available_socket();
+                                if(result != NRK_ERROR)
+                                {
+                                        sock[result].pid = nrk_get_pid();
+                                        sock[result].type = SOCK_IPC;
+                                }
+                                break;
+        
                 default: 
                                 _nrk_errno_set(UNSUPPORTED_SOCK_TYPE);
@@ -124 +137 @@
         }
                 
-        leave_cr(tl_sem, "create_socket()");
+        leave_cr(tl_sem, 3);
         return result; 
 }
 
 /*****************************************************************************************/
-int8_t get_next_available_port()
-// This private function gets the next available ephemeral port number if present or NRK_ERROR
-// if all are taken 
+uint8_t get_next_available_port()
+{
+        uint8_t i;      // loop index for the ephemeral ports 
+        int8_t j;       // loop index
+        
+        for(i = EPHEMERAL_PORT_NUM_START; i <= MAX_PORT_NUM; i++)
+        {
+                // check to see if port 'i' is available 
+                for(j = 0; j < MAX_PORTS; j++)
+                        if(ports[j].pno == i)   // port 'i' is taken 
+                                break;
+                                
+                if(j == MAX_PORTS)                      // port 'i' is free
+                        return i;                                       // return this ephemeral port number 
+        }
+        
+        // if the code reaches this point, it means that all the ephemeral port numbers are taken                        
+        _nrk_errno_set(NO_PORTS_AVAILABLE);
+        return INVALID_PORT;                                                     
+}
+/******************************************************************************************/
+int8_t check_port_available(uint8_t pt)
 {
         int8_t i;       // loop index 
-        if(DEBUG_TL == 2)
-                printf("Inside get_next_available_ports(). Value of ports = %d\r\n", ports); 
-        
-        //for(i = EPHEMERAL_PORT_NUM_START; i <= MAX_PORTS; i++)        // check only for ephemeral port numbers
-        for(i = 3; i <= MAX_PORTS; i++) 
-        {
-                if(DEBUG_TL == 2)
-                        printf("Inside get_next_available_ports(). i = %d\r\n", i);
-                if( ((ports >> i) & ((uint32_t)1)) == 0 )       // bit 'i' is 0 
+        
+        for(i = 0; i < MAX_PORTS; i++)
+                if(ports[i].pno == pt)          // port 'pt' has been taken
+                {
+                        _nrk_errno_set(PORT_UNAVAILABLE);               
+                        return NRK_ERROR;
+                }
+        
+        // if the code reaches here, it means that port 'pt' is available 
+        return NRK_OK;
+}
+
+/********************************************************************************************/
+int8_t assign_port(Port *p, uint8_t pt)
+{
+        int8_t ret1, ret2;      // to hold the return values of various functions
+                
+        // fill up the members of the port element 
+        p -> pno = pt;
+        p -> send_done_signal = nrk_signal_create();
+        p -> data_arrived_signal = nrk_signal_create();
+        
+        if(p -> send_done_signal == NRK_ERROR) 
+        {
+                if(DEBUG_TL == 1)
+                        nrk_kprintf(PSTR("assign_port(): Error creating send_done signal\r\n"));
+                        
+                _nrk_errno_set(NO_SIGNALS_AVAILABLE);
+                return NRK_ERROR;
+        }
+        
+        if(p -> data_arrived_signal == NRK_ERROR)
+        {
+                if(DEBUG_TL == 1)
+                        nrk_kprintf(PSTR("assign_port(): Error creating data_arrived signal\r\n", pt);
+                        
+                _nrk_errno_set(NO_SIGNALS_AVAILABLE);
+                return NRK_ERROR;
+        }
+        
+        ret1 = nrk_signal_register(p -> send_done_signal);
+        ret2 = nrk_signal_register(p -> data_arrived_signal);
+        if(ret1 == NRK_ERROR)
+        {
+                nrk_int_disable();
+                nrk_led_set(RED_LED);
+                while(1)
+                        nrk_kprintf(PSTR("assign_port(): Error registering send_done signal\r\n"));
+        }
+        if(ret2 == NRK_ERROR)
+        {
+                nrk_int_disable();
+                nrk_led_set(RED_LED);
+                while(1)
+                        nrk_kprintf(PSTR("assign_port(): Error registering data_arrived signal\r\n", pt));
+        }
+        
+        return NRK_OK;  
+}
+/******************************************************************************************/
+void release_port(Port *p)
+{
+        int8_t ret1, ret2;      // to hold the return type of function calls    
+        
+        // invalidate the members of the given port element     
+        p -> port = INVALID_PORT;
+        ret1 = nrk_signal_delete(p -> send_done_signal);
+        ret2 = nrk_signal_delete(p -> data_arrived_signal);     
+        
+        if(ret1 == NRK_ERROR )
+        {
+                nrk_int_disable();
+                nrk_led_set(RED_LED);
+                while(1)
+                        nrk_kprintf(PSTR("release_port(): Error deleting send_done signal\r\n"));
+        }
+
+        if(ret2 == NRK_ERROR)
+        {
+                nrk_int_disable();
+                nrk_led_set(RED_LED);
+                while(1)
+                        nrk_kprintf(PSTR("release_port(): Error deleting send_done_signal\r\n"));
+        }
+        return; 
+}
+/*****************************************************************************************/
+int8_t get_index_unassigned_port_element()
+{
+        int8_t i;       // loop index
+        
+        for(i = 0; i < MAX_PORTS; i++)
+                if(ports[i].pno == INVALID_PORT)
                         return i;
-        }
-        _nrk_errno_set(NO_PORTS_AVAILABLE);     
-        return NRK_ERROR;                                                        
-}
-/******************************************************************************************/
-int8_t check_port_available(int8_t pt)
-// This private function checks to see if port 'pt' is available and returns NRK_OK or NRK_ERROR 
-// accordingly 
-{
-        if( ((ports >> pt) & ((uint32_t)1)) == 0 )                      // bit 'pt' is 0 
-                return NRK_OK;
-        
-        _nrk_errno_set(PORT_UNAVAILABLE);       
+                        
+        _nrk_errno_set(NO_PORT_ELEMENT_AVAILABLE);
         return NRK_ERROR;
 }
-/*****************************************************************************************/
-void assign_port(int8_t pt)
-// This private function records the fact that port 'pt' has been assigned 
-{
-        ports |= (uint32_t)1 << pt;                     // set bit 'pt' in 'ports'
-        return;
-}
-/******************************************************************************************/
-void release_port(int8_t pt)
-// This private function records the fact that port 'pt' is now released 
-{
-        ports &= ~( (uint32_t)1 << pt );                // clear bit 'pt' in 'ports'
-        return; 
-}
-
-/*****************************************************************************************/
+/*******************************************************************************************/
+int8_t get_index_unassigned_rbm_element()
+{
+        int8_t i;
+        
+        for(i = 0; i < MAX_PORTS; i++)
+                if(rx_buf_mgr[i].port == NULL)  
+                        return i;
+                        
+        _nrk_errno_set(NO_RBM_ELEMENT_AVAILABLE);
+        return NRK_ERROR;
+}
+/*********************************************************************************************/
 int8_t bind(int8_t sock_num, int8_t port)
 {
-        int8_t index;                                                   // stores the index of next available receive buffer                     
+        int8_t buf_index;                                               // stores the index of next available receive buffer
+        int8_t port_index;                                      // stores the index of the next available port element
+        int8_t rbm_index;                                               // stores the index of the next available rbm element 
         int8_t i;                                                               // loop index 
         int8_t size;                                                    // size of receive queue allocated for this port 
-        
-        enter_cr(bm_sem, 8);    
+        Port *p;                                                                        // pointer to port element 
+        
+        enter_cr(bm_sem, 8);                                    // capture the necessary semaphores 
         enter_cr(tl_sem, 8);
                         
-        if(tlayer_init_done != 1)
+        // ERROR CHECKING       
+        if(tlayer_init_done != 1)                       // transport layer not initialised 
         {
                 nrk_int_disable();
@@ -192 +298 @@
         }
                                 
-        // ERROR CHECKING 
         if(sock_num < 0 || sock_num >= MAX_PORTS)       // bad input 
         {
                 _nrk_errno_set(INVALID_ARGUMENT);
                 
-                leave_cr(tl_sem, "bind()");     
-                leave_cr(bm_sem, "bind()");     
+                leave_cr(tl_sem, 8);    
+                leave_cr(bm_sem, 8);    
                 return NRK_ERROR;
         }
@@ -206 +311 @@
                 _nrk_errno_set(INVALID_ARGUMENT);
                 
-                leave_cr(tl_sem, "bind()");     
-                leave_cr(bm_sem, "bind()");
+                leave_cr(tl_sem, 8);    
+                leave_cr(bm_sem, 8);
                 return NRK_ERROR;
         }
@@ -215 +320 @@
                 _nrk_errno_set(INVALID_SOCKET);
                 
-                leave_cr(tl_sem, "bind()");     
-                leave_cr(bm_sem, "bind()");
-                return NRK_ERROR;
-        }
-        
-        if(rx_buf_mgr[port].pid == nrk_get_pid())       // bind() / set_rx_queue_size() was called earlier
+                leave_cr(tl_sem, 8);    
+                leave_cr(bm_sem, 8);
+                return NRK_ERROR;
+        }
+        
+        if(sock[sock_num].port != NULL) // bind() / set_rx_queue_size() was called earlier
         {
                 _nrk_errno_set(INVALID_CALL);
                 
-                leave_cr(tl_sem, "bind()");     
-                leave_cr(bm_sem, "bind()");
-                return NRK_ERROR;
-        }
-        
-        if(check_port_available(port) == NRK_ERROR)             // check to see if port is already taken 
-        {
-                leave_cr(tl_sem, "bind()");     
-                leave_cr(bm_sem, "bind()");     
+                leave_cr(tl_sem, 8);    
+                leave_cr(bm_sem, 8);
+                return NRK_ERROR;
+        }
+        
+        if(check_port_available((uint8_t)port) == NRK_ERROR)            // check to see if port is already taken 
+        {
+                leave_cr(tl_sem, 8);    
+                leave_cr(bm_sem, 8);    
                 return NRK_ERROR;                                                                               // error no is already set = PORT_UNAVAILABLE
         } 
@@ -240 +345 @@
                 _nrk_errno_set(NO_RX_BUFFERS_AVAILABLE);
                 
-                leave_cr(tl_sem, "bind()");     
-                leave_cr(bm_sem, "bind()");
-                return NRK_ERROR;
-        }
-                                
+                leave_cr(tl_sem, 8);    
+                leave_cr(bm_sem, 8);
+                return NRK_ERROR;
+        }
+        
+        // error checking complete. Begin processing     
         size = DEFAULT_RX_QUEUE_SIZE;
         // at this point, we know that
@@ -251 +357 @@
         // 3. bind() / setReceiveQueueSize() was not called earlier
         
-        // update the necessary state variables
-        sock[sock_num].port = port;                                     // assign the socket a port number 
-        assign_port(port);                                                              // set bit 'port' in 'ports' equal to 1
-        
-        rx_buf_mgr[port].pid = nrk_get_pid();           // fill up the members of the ReceiveBufferManager
-        if( nrk_signal_register(rx_buf_mgr[port].seg_arrived_signal) == NRK_ERROR )
+        // get the indices of the port element and the rbm element 
+        port_index = get_index_unassigned_port_element();
+        rbm_index = get_index_unassigned_rbm_element();
+        if(port_index == NRK_ERROR || buf_index == NRK_ERROR)   // this should not happen
         {
                 nrk_int_disable();
-                nrk_led_set(RED_LED);
-                while(1)
-                        nrk_kprintf(PSTR("bind(): Error while registering for seg_arrived_signal\r\n"));
-        }
-                
+                nrk_set_led(RED_LED);
+                while(1)
+                        nrk_kprintf(PSTR("bind(): Bug discovered in implementation of port/rbm element array\r\n"));
+        } 
+
+        // fill up the members of the port element      
+        assign_port( &ports[port_index], (uint8_t)port);        
+        
+        // fill up the members of the socket            
+        sock[sock_num].port = &ports[port_index];       
+        sock[sock_num].rbm = &rx_buf_mgr[rbm_index]
+        
+        // fill up the members of the receive buffer manager     
+        rx_buf_mgr[rbm_index].pid = nrk_get_pid();
+        rx_buf_mgr[rbm_index].port = &ports[port_index];        
+        
         // allocate 'size' buffers 
         for(i = 1; i <= size; i++)
         {
-                index = get_index_unallocated_rx_buf(); // look for the unallocated receive buffer 
-                if(index == NRK_ERROR)  //       this should not happen 
+                buf_index = get_index_unallocated_rx_buf();     // look for the unallocated receive buffer 
+                if(buf_index == NRK_ERROR)      //       this should not happen 
                 {
                         nrk_int_disable();
@@ -276 +391 @@
                 }
                 
-                insert_rx_fq(&rx_buf_udp[index], port, EMPTY);  // insert the buffer in the free queue of the port
-                rx_buf_mgr[port].countTotal++;                                          // increment the countTotal for this port 
+                // insert the buffer in the free queue of the port
+                insert_rx_fq(&rx_buf_udp[buf_index], rbm_index, EMPTY);
+                rx_buf_mgr[rbm_index].countTotal++;                     // increment the countTotal for this port 
                 num_bufs_free--;                
         }
         
-        leave_cr(tl_sem, "bind()");     
-        leave_cr(bm_sem, "bind()");
+        leave_cr(tl_sem, 8);    
+        leave_cr(bm_sem, 8);
         return NRK_OK; 
 }
@@ -288 +404 @@
 int8_t get_rx_queue_size(int8_t sock_num)
 {
-        int8_t port;            // to store the port number associated with this socket number 
-        int8_t count;
-        
-        enter_cr(bm_sem, 9);    
+        int8_t count;           // to store the number of rx buffers associated with the port number 
+        
+        enter_cr(bm_sem, 9);    // capture the necessary semaphores 
         enter_cr(tl_sem, 9);
         
@@ -313 +428 @@
         }
         
-        if(sock[sock_num].port == INVALID_PORT) // no socket operations were performed yet
+        if(sock[sock_num].port == NULL) // no socket operations were performed yet
         {
                 leave_cr(tl_sem, 9);    
                 leave_cr(bm_sem, 9);    
-                return 0;
-        }
-                
-        // at this point we know that some socket operation has been performed on the socket prior to this call
-        port = sock[sock_num].port;
-        count = rx_buf_mgr[port].countTotal;
+                return 0;                                                       // hence return 0 
+        }
+        
+        if(sock[sock_num].rbm == NULL)  // this should not happen
+        {
+                nrk_int_disable();
+                nrk_led_set(RED_LED);
+                while(1)
+                        nrk_kprintf(PSTR("get_rx_queue_size(): Bug discovered in implementation of sock array\r\n"));
+        }               
+        // at this point we know that some socket operation has been performed on the socket
+        // prior to this call
+        count = sock[sock_num].rbm -> countTotal;
         
         leave_cr(tl_sem, 9);    
@@ -332 +454 @@
 int8_t set_rx_queue_size(int8_t sock_num, int8_t size)
 {
-        int8_t port;            // to store the port number associated with given socket number
+        uint8_t port;           // to store the port number associated with given socket number
         int8_t i;                       // loop index
         int8_t flag;            // to mark whether bind() was called prior to this call or not 
-        int8_t index;           // stores the index of next unallocated receive buffer  
-                
-        enter_cr(bm_sem, 10);
+        int8_t buf_index;       // stores the index of next unallocated receive buffer
+        int8_t rbm_index; // stores the index of an unassigned rbm element
+        int8_t port_index;// stores the index of an unassigned port element  
+                
+        enter_cr(bm_sem, 10);   // capture the necessary semaphores 
         enter_cr(tl_sem, 10);
                 
@@ -368 +492 @@
         }
         
-        if(sock[sock_num].port == INVALID_PORT) // there is no port associated with this socket yet
+        if(sock[sock_num].port == NULL)                         // there is no port associated with this socket yet
         {
                 flag = 1;                                                                               // bind() was not called earlier 
                 port = get_next_available_port();               // search for a ephemeral port number 
-                if(port == NRK_ERROR)                                           // no port available 
+                if(port == INVALID_PORT)                                        // no port available 
                 {
                         leave_cr(tl_sem, 10);
@@ -387 +511 @@
            }
                 // port available and default num of buffers available, 
-                // assign the new port number to the socket desc                
-                sock[sock_num].port = port;
-                assign_port(port);
-                if( nrk_signal_register(rx_buf_mgr[port].seg_arrived_signal) == NRK_ERROR )
+                // get the indices of the rbm and port element 
+                port_index = get_index_unassigned_port_element();
+                rbm_index = get_index_unassigned_rbm_element();
+                
+                if(port_index == NRK_ERROR || rbm_index == NRK_ERROR)   // this should not happen 
                 {
                         nrk_int_disable();
                         nrk_led_set(RED_LED);
                         while(1)
-                                nrk_kprintf(PSTR("set_rx_queue_size(): Error registering for seg_arrived_signal\r\n"));
-                } 
-        }
+                                nrk_kprintf(PSTR("set_rx_queue_size(): Bug discovered in implementation of port/rbm array"));
+                }       
+                
+                // fill up the contents of the port 
+                assign_port(&ports[port_index], port);
+                                
+                // fill up the members of the socket descriptor
+                sock[sock_num].port = &ports[port_index];
+                sock[sock_num].rbm = &rx_buf_mgr[rbm_index];
+                                
+                // fill up the members of the rbm element
+                rx_buf_mgr[rbm_element].pid = nrk_get_pid();
+                rx_buf_mgr[rbm_element].port = &ports[port_index];
+                
+        } // end if(bind was not called earlier)
         else // bind was called earlier. DEFAULT_RX_QUEUE_SIZE buffers already allocated
         {
-                // FIX ME 
                 if(size == DEFAULT_RX_QUEUE_SIZE)       // nothing to do, buffers already allocated
                 {
@@ -407 +543 @@
                         return size;
                 }
-        }
-        
-        // check to see if there are 'size' buffers available in the system     
+                else                                                                                    // size > DEFAULT_RX_QUEUE_SIZE 
+                        size -= DEFAULT_RX_QUEUE_SIZE;
+        }
+        
+        // at this point, the socket has been given a valid port number and a receive buffer manager
+        // with at least one receive buffer available for its use
+                
+        // check to see if there are actually 'size' buffers available in the system    
         if(get_num_bufs_free() < size)
                 size = get_num_bufs_free();
                 
-        // at this point, the socket is associated with a valid port number
-        // and at least one receive buffer is free
-        // fill in the values of the corresponding ReceiveBufferManager
-        rx_buf_mgr[port].pid = nrk_get_pid();
-        
         // allocate 'size' buffers 
         for(i = 1; i <= size; i++)
         {
-                index = get_index_unallocated_rx_buf(); // look for the next unallocated receive buffer 
-                if(index == NRK_ERROR)  //       this should not happen 
+                buf_index = get_index_unallocated_rx_buf();     // look for the next unallocated receive buffer 
+                if(buf_index == NRK_ERROR)      //       this should not happen 
                 {
                         nrk_int_disable();
@@ -429 +565 @@
                                 nrk_kprintf(PSTR("set_rx_queue_size(): Bug found in implementation of num_bufs_free\r\n"));
                 }               
-                insert_rx_fq(&rx_buf_udp[index], port, EMPTY);  // insert the buffer in the free queue of the port
-                rx_buf_mgr[port].countTotal++; 
+                // insert the buffer in the free queue of the port              
+                insert_rx_fq(&rx_buf_udp[buf_index], rbm_index, EMPTY);
+                rx_buf_mgr[rbm_index].countTotal++; 
                 num_bufs_free--;                
         }
@@ -441 +578 @@
 int8_t release_buffer(int8_t sock_num, uint8_t *ptr)
 {
-        int8_t port;                                            // to store the port number associated with the socket
+        int8_t rbm_index;                                       // index of the rbm element associated with this socket 
         ReceiveBufferUDP *buf;                  // pointer to traverse the buffer list of the free queue 
         
@@ -464 +601 @@
                 return NRK_ERROR;
         }
-        if(sock[sock_num].port == INVALID_PORT) // if no socket operation was performed earlier 
+        if(sock[sock_num].port == NULL) // if no socket operation was performed earlier 
         {
                 _nrk_errno_set(INVALID_SOCKET);
@@ -473 +610 @@
         }
                 
-        port = sock[sock_num].port;                               // retrieve the port number from the socket descriptor 
+        if(sock[sock_num].rbm == NULL)  // this should not happen. Sanity check 
+        {
+                nrk_int_disable();
+                nrk_led_set(RED_LED);
+                while(1)
+                        nrk_kprintf(PSTR("release_buffer(): Bug discovered in implementation of sock element\r\n"));
+        }       
         
         // check to see if the pointer passed is valid
-        buf = rx_buf_mgr[port].head_fq;
+        buf = sock[sock_num].rbm -> head_fq;
         while(buf != NULL)
         {
@@ -493 +636 @@
                 
         buf -> status = EMPTY;          // mark the buffer as available now
-        rx_buf_mgr[port].countFree++; 
+        (sock[sock_num].rbm -> countFree)++; 
         
         leave_cr(tl_sem, 11);   
@@ -502 +645 @@
 int8_t close_socket(int8_t sock_num)
 {
-        int8_t port;                            // to store the port number assoicated with the given socket number
         ReceiveBufferUDP *ptr;  // temp variable 
                 
@@ -527 +669 @@
                 
         // Free up resources associated with this socket descriptor 
-        port = sock[sock_num].port;
-        if(port != INVALID_PORT)        // some operation was performed earlier with this socket 
-        {
-                rx_buf_mgr[port].pid = INVALID_PID;
-                if( nrk_signal_delete(rx_buf_mgr[port].seg_arrived_signal) == NRK_ERROR )
+        if(sock[sock_num].port != NULL) // some operation was performed earlier with this socket 
+        {
+                // remove all the FULL buffers from the port queue                      
+                while( (ptr = remove_rx_pq(sock[sock_num].rbm)) != NULL )               
+                        ptr -> status = UNALLOCATED;            
+                        
+                // remove all the EMPTY buffers from the free queue             
+                while( (ptr = remove_rx_fq(sock[sock_num].rbm, EMPTY)) != NULL ) 
+                        ptr -> status = UNALLOCATED;
+                        
+                // remove all the FULL buffers from the free queue              
+                while( (ptr = remove_rx_fq(sock[sock_num].rbm, FULL)) != NULL )
+                        ptr -> status = UNALLOCATED;
+
+                // free up the rbm element              
+                sock[sock_num].rbm -> pid = INVALID_PID;
+                sock[sock_num[.rbm -> port = NULL;              
+                                
+                // release the port             
+                release_port(sock[sock_num].port);
+        }  
+        
+        sock[sock_num].port = NULL;
+        sock[sock_num].pid = INVALID_PID;
+        sock[sock_num].rbm = NULL;
+        
+        leave_cr(tl_sem, 12);
+        leave_cr(bm_sem, 12);   
+        return NRK_OK;
+}
+/************************************************************************************************/
+int8_t is_port_associated(int16_t port)
+{
+        // ERROR checking
+        if(port <= 0 || port > MAX_PORT_NUM)    // bad input
+        {
+                _nrk_errno_set(INVALID_ARGUMENT);
+                return NRK_ERROR;
+        }       
+        
+        enter_cr(tl_sem, 13);
+        if(check_port_available((uint8_t)port) == NRK_OK)
+        {
+                leave_cr(tl_sem, 13);
+                return FALSE;
+        }
+        leave_cr(tl_sem, 13);
+        return TRUE;
+}
+/************************************************************************************************/ 
+int8_t send(int8_t sock_num, uint8_t *ptr, int8_t len, int32_t dest_addr, int8_t dest_port, int8_t prio)
+{
+        int8_t result;                  // to hold the return type of various functions 
+        
+        if(DEBUG_TL == 2)
+                nrk_kprintf(PSTR("Entered send operation of TL\r\n"));
+                        
+        enter_cr(bm_sem, 14);
+        enter_cr(tl_sem, 14);
+        
+        // ERROR checking
+        if(sock_num < 0 || sock_num >= MAX_PORTS)                                                               // bad input 
+        {
+                _nrk_errno_set(INVALID_ARGUMENT);
+                
+                leave_cr(tl_sem, 14);
+                leave_cr(bm_sem, 14);           
+                return NRK_ERROR;
+        }
+                
+        if(ptr == NULL || len <= 0 || len > MAX_APP_PAYLOAD)                            // bad input 
+        {
+                _nrk_errno_set(INVALID_ARGUMENT);
+                
+                leave_cr(tl_sem, 14);
+                leave_cr(bm_sem, 14);
+                return NRK_ERROR;
+        }
+                
+        if(dest_addr < 0 || dest_port <= 0 || dest_port > MAX_PORTS)    // bad input 
+        {
+                _nrk_errno_set(INVALID_ARGUMENT);
+                
+                leave_cr(tl_sem, 14);
+                leave_cr(bm_sem, 14);
+                return NRK_ERROR;
+        }
+        
+        if(prio <= 0 || prio > MAX_PRIORITY)                                                                    // bad input 
+        {
+                _nrk_errno_set(INVALID_ARGUMENT);
+                
+                leave_cr(tl_sem, 14);
+                leave_cr(bm_sem, 14);
+                return NRK_ERROR;
+        }
+                
+        if(sock[sock_num].pid != nrk_get_pid())                                                         // wrong socket number 
+        {
+                _nrk_errno_set(INVALID_SOCKET);
+                
+                leave_cr(tl_sem, 14);
+                leave_cr(bm_sem, 14);
+                return NRK_ERROR;
+        }
+                
+        /* Error checking is complete. Begin processing */
+        if(sock[sock_num].port == NULL) // this means that bind() / set_rx_queue_size() was 
+                                                                                                // not called earlier
+        {
+                int8_t buf_index, rbm_index, port_index;
+                uint8_t port;
+                
+                // retrieve the corresponding indices
+                rbm_index = get_index_unassigned_rbm_element();
+                port_index = get_index_unassigned_port_element();
+                if(rbm_index == NRK_ERROR || port_index == NRK_ERROR)   // this should not happen
                 {
                         nrk_int_disable();
                         nrk_led_set(RED_LED);
                         while(1)
-                                nrk_kprintf(PSTR("close_socket(): Error in deleting seg_arrived_signal\r\n"));
+                                nrk_kprintf(PSTR("send(): Bug detected in implementation of port and rbm array\r\n"));
                 }
-
-                // remove all the FULL buffers from the port queue                      
-                while( (ptr = remove_rx_pq(port)) != NULL )             
-                        ptr -> status = UNALLOCATED;            
-                        
-                // remove all the EMPTY buffers from the free queue             
-                while( (ptr = remove_rx_fq(port, EMPTY)) != NULL ) 
-                        ptr -> status = UNALLOCATED;
-                        
-                // remove all the FULL buffers from the free queue              
-                while( (ptr = remove_rx_fq(port,FULL)) != NULL )
-                        ptr -> status = UNALLOCATED;
-                
-                release_port(port);
-        }  
-        
-        sock[sock_num].port = INVALID_PORT;
-        sock[sock_num].pid = INVALID_PID;
-        
-        leave_cr(tl_sem, 12);
-        leave_cr(bm_sem, 12);   
-        return NRK_OK;
-}
-/************************************************************************************************/
-int8_t is_port_associated(int8_t port)
-{
-        enter_cr(tl_sem, 13);
-                
-        if(check_port_available(port) == NRK_OK)
-        {
-                leave_cr(tl_sem, 13);
-                return FALSE;
-        }
-        leave_cr(tl_sem, 13);
-        return TRUE;
-}
-/************************************************************************************************/ 
-int8_t send(int8_t sock_num, uint8_t *ptr, int8_t len, int16_t dest_addr, int8_t dest_port, int8_t prio)
-{
-        int8_t port;                    // to hold the port number corresponding to the socket number passed
-        int8_t result;                  // to hold the return type of various functions 
-        
-        if(DEBUG_TL == 2)
-                nrk_kprintf(PSTR("Entered send operation of TL\r\n"));
-                        
-        enter_cr(bm_sem, 14);
-        enter_cr(tl_sem, 14);
-        
-        if(DEBUG_TL == 2)
-                nrk_kprintf(PSTR("Inside CR of send operation of TL\r\n"));
-        
-        // ERROR checking
-        if(sock_num < 0 || sock_num >= MAX_PORTS)                                                               // bad input 
-        {
-                _nrk_errno_set(INVALID_ARGUMENT);
-                
-                leave_cr(tl_sem, 14);
-                leave_cr(bm_sem, 14);           
-                return NRK_ERROR;
-        }
-                
-        if(ptr == NULL || len <= 0 || len > MAX_APP_PAYLOAD)                            // bad input 
-        {
-                _nrk_errno_set(INVALID_ARGUMENT);
-                
-                leave_cr(tl_sem, 14);
-                leave_cr(bm_sem, 14);
-                return NRK_ERROR;
-        }
-                
-        if(dest_addr < 0 || dest_port <= 0 || dest_port > MAX_PORTS)    // bad input 
-        {
-                _nrk_errno_set(INVALID_ARGUMENT);
-                
-                leave_cr(tl_sem, 14);
-                leave_cr(bm_sem, 14);
-                return NRK_ERROR;
-        }
-        
-        if(prio <= 0 || prio > MAX_PRIORITY)                                                                    // bad input 
-        {
-                _nrk_errno_set(INVALID_ARGUMENT);
-                
-                leave_cr(tl_sem, 14);
-                leave_cr(bm_sem, 14);
-                return NRK_ERROR;
-        }
-                
-        if(sock[sock_num].pid != nrk_get_pid())                                                         // wrong socket number 
-        {
-                _nrk_errno_set(INVALID_SOCKET);
-                
-                leave_cr(tl_sem, 14);
-                leave_cr(bm_sem, 14);
-                return NRK_ERROR;
-        }
-                
-        /* Error checking is complete. Begin processing */
-        if(sock[sock_num].port == INVALID_PORT) // this means that bind() / set_rx_queue_size() was 
-                                                                                                                        // not called earlier
-        {
-                // FIX ME IMPORTANT.................    
-                leave_cr(tl_sem, 14);
-                leave_cr(bm_sem, 14);   
-                result = set_rx_queue_size(sock_num, DEFAULT_RX_QUEUE_SIZE);
-                enter_cr(bm_sem, 14);
-                enter_cr(tl_sem, 14);
-                if(result == NRK_ERROR)         // error number will be set already 
-                {
-                        leave_cr(tl_sem, 14);
-                        leave_cr(bm_sem, 14);           
+                buf_index = get_index_unallocated_rx_buf();
+                if(buf_index == NRK_ERROR)
+                        return NRK_ERROR;                       // error no is already set to NO_RX_BUFFERS_AVAILABLE 
+                        
+                port = get_next_available_port();
+                if(port == INVALID_PORT)        // error no is already set to NO_PORTS_AVAILABLE        
                         return NRK_ERROR;
-                }
-        }
-        port = sock[sock_num].port;     // retrieve the port number
-        // register for the 'send done' signal 
-        if( nrk_signal_register(sd_sig[port].send_done_signal) == NRK_ERROR )
-        {
-                nrk_int_disable();
-                nrk_led_set(RED_LED);
-                while(1)
-                        nrk_kprintf(PSTR("send(): Error while registering for send_done_signal\r\n"));
-        }       
-                
+                
+                // fill up the members of the port
+                assign_port(&ports[port_index], port);
+                                
+                // fill up the members of the socket 
+                sock[sock_num].port = &ports[port_index];
+                sock[sock_num].rbm = &rx_buf_mgr[rbm_index];
+                
+                // fill up the members of the receive buffer manager
+                rx_buf_mgr[rbm_index].port = &ports[port_index];
+                rx_buf_mgr[rbm_index].pid = nrk_get_pid();
+                insert_rx_fq(&rx_buf_udp[buf_index], rbm_index, EMPTY);
+                rx_buf_mgr[rbm_index].countTotal++; 
+                num_bufs_free--;        
+        }
+        
         // prepare a UDP segment 
-        udp_seg.srcPort = port;
+        udp_seg.srcPort = sock[sock_num].port -> pno;
         udp_seg.destPort = dest_port;
         udp_seg.length = len;
@@ -680 +833 @@
         // insert the packet into the active transmit queue of the system
         
-        if(DEBUG_TL == 2)
-                nrk_kprintf(PSTR("Inside send(). Before inserting packet in transmit queue\r\n"));
-                
-        result = insert_tx_aq(&pkt);
-        
-        if(DEBUG_TL == 2)
-                nrk_kprintf(PSTR("Inside send(). After inserting packet in transmit queue\r\n"));
-                
+        result = insert_tx_aq(&pkt);
+        
         if(result == NRK_ERROR)
                 _nrk_errno_set(NO_TX_BUFFERS_AVAILABLE);
@@ -736 +883 @@
 }
 /*************************************************************************************************/
-uint8_t* receive(int8_t sock_num, int8_t *len, int8_t *srcAddr, int8_t *srcPort, int8_t *rssi)
-{
-        int8_t port;                                    // to hold the port number associated with the passed socket number     
-        nrk_sig_mask_t my_sigs;         // to hold the return value of network layer signals 
-        ReceiveBufferUDP *buf;          // temporary variable 
-        Transport_Segment_UDP *seg;// pointer to received segment from the network layer 
+uint8_t* receive(int8_t sock_num, int8_t *len, uint16_t *srcAddr, uint8_t *srcPort, int8_t *rssi)
+{
+        nrk_sig_mask_t my_sigs;                 // to hold the return value of network layer signals 
+        ReceiveBufferUDP *buf;                  // temporary variable 
+        Transport_Segment_UDP *seg;     // pointer to received segment from the network layer 
         
         enter_cr(bm_sem, 16);
@@ -756 +902 @@
         }
 
-        if( sock[sock_num].pid != nrk_get_pid() || sock[sock_num].port == INVALID_PORT )
+        if( sock[sock_num].pid != nrk_get_pid() || sock[sock_num].port == NULL )
         {
                 _nrk_errno_set(INVALID_SOCKET); // socket description not complete
@@ -766 +912 @@
         
         // error checking complete. Begin processing    
-        port = sock[sock_num].port;
         if(sock[sock_num].timeout.secs == 0 && sock[sock_num].timeout.nano_secs == 0)
         {
@@ -774 +919 @@
                 
                 // check the receive buffer manager for this port to see if there are any queued segments
-                if(rx_buf_mgr[port].countFree == rx_buf_mgr[port].countTotal)   // no queued segments 
+                if(sock[sock_num].rbm -> countFree == sock[sock_num].rbm -> countTotal) // no queued segments 
                 {
                         if(DEBUG_TL == 2)
-                                printf("receive(): No segments in receive queue of port = %d\n", port);
+                                printf("receive(): No segments in receive queue of port = %d\n", sock[sock_num].port -> pno);
+                        
                         while(1)
                         {
                                 leave_cr(tl_sem, 16);
                                 leave_cr(bm_sem, 16);
-                                my_sigs = nrk_event_wait(SIG(rx_buf_mgr[port].seg_arrived_signal));     // block
+                                my_sigs = nrk_event_wait(SIG(sock[sock_num].port -> data_arrived_signal));      // block
                                 enter_cr(bm_sem, 16);
                                 enter_cr(tl_sem, 16);  
                 
                                 // check what signal we got 
-                        if(my_sigs == 0)                       
+                        if(my_sigs == 0)        // this should not happen                       
                         {
                                 nrk_int_disable();
@@ -794 +940 @@
                                                 nrk_kprintf(PSTR("receive(): Error calling nrk_event_wait (without timeout)\r\n"));
                                 }       
-                                if( my_sigs & SIG(rx_buf_mgr[port].seg_arrived_signal) )        // got a segment 
+                                if( my_sigs & SIG(sock[sock_num].port -> data_arrived_signal) ) // got a segment 
                                 {
                                         if(DEBUG_TL == 2)
-                                        nrk_kprintf(PSTR("receive(): Received the seg arrived signal\r\n"));
+                                        nrk_kprintf(PSTR("receive(): Received the data_arrived signal\r\n"));
                                 break;
                         }
@@ -813 +959 @@
         {
                 if(DEBUG_TL == 2)
-                        nrk_kprintf(PSTR("receive(): Inside the section that relates to 'with timeout' receive\r\n"));
+                        nrk_kprintf(PSTR("receive(): Inside the section that relates to 'with timeout'\r\n"));
                         
                 if( nrk_signal_register(nrk_wakeup_signal) == NRK_ERROR)
@@ -820 +966 @@
                         nrk_led_set(RED_LED);
                         while(1)
-                                nrk_kprintf(PSTR("receive(): Error in registering for nrk_wakeup_signal (with timeout)\r\n"));
+                                nrk_kprintf(PSTR("receive(): Error in registering for nrk_wakeup_signal\r\n"));
                 }
                 if( nrk_set_next_wakeup(sock[sock_num].timeout) == NRK_ERROR)
@@ -827 +973 @@
                         nrk_led_set(RED_LED);
                         while(1)
-                                nrk_kprintf(PSTR("receive(): Error returned by nrk_set_next_wakeup (with timeout)\r\n"));
+                                nrk_kprintf(PSTR("receive(): Error returned by nrk_set_next_wakeup()\r\n"));
                 }               
                 // check the receive manager for this port to see if there are any queued segments
-                if(rx_buf_mgr[port].countFree == rx_buf_mgr[port].countTotal)   // no queued segments 
+                if(sock[sock_num].rbm -> countFree == sock[sock_num].rbm -> countTotal) // no queued segments 
                 {
                         while(1)
@@ -836 +982 @@
                                 leave_cr(tl_sem, 16);
                                 leave_cr(bm_sem, 16);
-                                my_sigs = nrk_event_wait(SIG(rx_buf_mgr[port].seg_arrived_signal) | SIG(nrk_wakeup_signal));
+                                my_sigs = nrk_event_wait(SIG(sock[sock_num].rbm -> data_arrived_signal) | SIG(nrk_wakeup_signal));
                                 enter_cr(bm_sem, 16);
                                 enter_cr(tl_sem, 16);                                    
@@ -848 +994 @@
                                                 nrk_kprintf(PSTR("receive(): Error calling nrk_event_wait() (with timeout)\r\n"));
                                 }       
-                        if( my_sigs & SIG(rx_buf_mgr[port].seg_arrived_signal) )        // got a segment 
+                        if( my_sigs & SIG(rx_buf_mgr[port].data_arrived_signal) )       // got a segment 
                         {
                                 sock[sock_num].timeout.secs = 0;                // invalidate the timeout 
                                 sock[sock_num].timeout.nano_secs = 0;
                                 if(DEBUG_TL == 2)
-                                        nrk_kprintf(PSTR("Received the seg arrived signal\r\n"));
-                                // FIX me change the wakeup period back to what it was
-                                break;
+                                        nrk_kprintf(PSTR("Received the data_arrived signal\r\n"));
+                                break; 
                         }
         
@@ -862 +1007 @@
                                 sock[sock_num].timeout.secs = 0;                        // invalidate the timeout value of the socket 
                                 sock[sock_num].timeout.nano_secs = 0;
-                                // FIX me change the wakeup period back to what it was 
                                 _nrk_errno_set(SOCKET_TIMEOUT);
                                 
@@ -1080 +1224 @@
 }
 /**********************************************************************************************/
+void insert_pe_aq(Port *p)
+{
+        // the new element always goes at the tail of the queue 
+        if(port_mgr.head_aq == NULL)    // the active queue is empty
+        {
+                port_mgr.head_aq = port_mgr.tail_aq = p;
+        }
+        else
+        {
+                port_mgr.tail_aq -> next = p;
+                port_mgr.tail_aq = p;
+        }
+        
+        p -> next = NULL;
+        port_mgr.count_aq++;
+        
+        return;
+}
+/************************************************************************************************/
+int8_t remove_pe_aq(Port *pt)
+{
+        Port *ptr = port_mgr.head_aq;
+        Port *prev = NULL;
+        
+        if(ptr == NULL) // the active queue is empty 
+                return NRK_OK;
+                
+        if(port_mgr.head_aq == port_mgr.tail_aq)        // only one element in the active queue 
+        {
+                if(ptr == pt)   // found the port element
+                {
+                        port_mgr.head_aq = port_mgr.tail_aq = NULL;
+                        port_mgr.count_aq--;
+                        return NRK_OK;
+                }
+                else    // port element is not present in the active queue 
+                {
+                        return NRK_ERROR;
+                }
+        }
+        
+        // if the code reaches here it means there are at least two elements in the active queue 
+        
+        while(ptr != NULL)
+        {
+                if(ptr == pt)   // found the port element
+                        break;
+                
+                prev  = ptr;
+                ptr = ptr -> next;
+        }
+        
+        if(ptr == NULL) // pt was not found in the active queue 
+                return NRK_ERROR;
+        
+        if(prev == NULL)        // pt is at the head of the active queue
+        {
+                port_mgr.head_aq = port_mgr_head_aq -> next;
+                port_mgr.count_aq--;
+                return NRK_OK;
+        }
+        else if(ptr == port_mgr.tail_aq)        // pt is found at the tail of the active queue
+                  {
+                                prev -> next = NULL;
+                                port_mgr.tail_aq = prev;
+                                port_mgr.count_aq--;
+                                return NRK_OK;
+                  }
+                  else                                                          // pt is found somewhere in the middle of the queue 
+                  {
+                                prev -> next = ptr -> next;
+                                port_mgr.count_aq--;
+                                return NRK_OK;
+                  }
+                  
+        return NRK_OK;
+}
+/***************************************************************************************************/
+void insert_pe_fq(Port *p)
+{
+        // the new element always goes at the tail of the queue 
+        if(port_mgr.head_fq == NULL)    // the free queue is empty
+        {
+                port_mgr.head_fq = port_mgr.tail_fq = p;
+        }
+        else
+        {
+                port_mgr.tail_fq -> next = p;
+                port_mgr.tail_fq = p;
+        }
+        
+        p -> next = NULL;
+        port_mgr.count_fq++;
+        
+        return;
+}       
+/***************************************************************************************************/
+Port* remove_pe_fq()
+{
+        Port *ptr;      // pointer to the head of the free queue 
+                
+        // the element at the head of the free queue is always removed
+        if(port_mgr.head_fq == NULL)    // the free queue is empty
+                return NULL;
+                
+        if(port_mgr.head_fq == port_mgr.tail_fq)        // only one element in the free queue
+                port_mgr.tail_fq = NULL;
+                
+        ptr = port_mgr.head_aq;
+        
+        port_mgr.head_aq = port_mgr.head_aq -> next;
+        port_mgr.count_fq--;
+        
+        return ptr;
+}
+/*************************************************************************************************/
+                
+        
+                        
+        
+                        
+        
+        
+                
+

nano-RK/projects/network_stack/TransportLayerUDP.h

@@ -19 +19 @@
 #define SOCK_RAW 3                                      // if the application wants to bypass the transport and network layers 
 
-#define EPHEMERAL_PORT_NUM_START 11             // 11 is the smallest port number available to user tasks
+#define EPHEMERAL_PORT_NUM_START 11             // smallest port number available to user tasks
+#define MAX_PORT_NUM 255                                        // largest port number available to user tasks 
 
 // limits on various object types 
@@ -29 +30 @@
 
 /********************************* DATA STRUCTURES ****************************************/
-
 typedef struct
 {
-        int8_t srcPort;                                         // source port of the application
-        int8_t destPort;                                                // destination port of the application
+        uint8_t srcPort;                                                // source port of the application
+        uint8_t destPort;                                               // destination port of the application
         int8_t length;                                                  // actual length of the data payload
         uint8_t data[MAX_APP_PAYLOAD];  // application layer data 
@@ -41 +41 @@
 typedef struct
 {
-        int8_t port;                                                    // port number associated with this socket descriptor 
-        int8_t pid;                                                             // pid of the process holding this socket descriptor
+        uint8_t pno;                                                    // the actual port number 
+        nrk_sig_t data_arrived_signal;  // 'data arrived' signal for this port 
+        nrk_sig_t send_done_signal;             // 'send done' signal for this port 
+        
+}Port; 
+
+typedef struct
+{
+        Port *port;                                                             // port information associated with this socket
+        ReceiveBufferManager *rbm;                      // receive buffer manager for this socket 
+        int8_t pid;                                                             // id of the process holding this socket  
         int8_t type;                                                    // type of socket
-        nrk_time_t timeout;                                     // to store a timeout value for the socket 
+        nrk_time_t timeout;                                     // to store a timeout value for the socket
 }Socket;
 
@@ -64 +73 @@
 
         PARAMS:         None
-        RETURNS:                index of the next available socket descriptor if available, NRK_ERROR otherwise
+        RETURNS:                index of the next available socket descriptor if available (0 - (MAX_PORTS - 1)),
+                                        NRK_ERROR otherwise
         ERROR NOS:      NO_SOCKET_DESC_AVAILABLE when no descriptors are available 
         COMMENTS:       private function 
@@ -71 +81 @@
 int8_t create_socket(int8_t type);
 /*
-This function creates a socket of a given type and returns it's descriptor
-
-        PARAMS:         type: The type of the socket. Currently only SOCK_DGRAM is supported
+This function creates a socket of a given type and returns it's descriptor number
+
+        PARAMS:         type: The type of the socket. Currently only SOCK_DGRAM and SOCK_IPC are supported
         RETURNS:                socket descriptor or NRK_ERROR otherwise
         ERROR NOS:      UNSUPPORTED_SOCK_TYPE if an invalid socket type is passed
@@ -80 +90 @@
 */
 
-int8_t get_next_available_port();
+uint8_t get_next_available_port();
 /*
 This function returns the next available port number if present
 
         PARAMS:         None
-        RETURNS:                port number if available, NRK_ERROR otherwise
+        RETURNS:                port number if available (EPHEMERAL_PORT_NUM_START - MAX_PORT_NUM)
+                                        INVALID_PORT otherwise
         ERROR NOS:      NO_PORTS_AVAILABLE if no ephemeral port numbers are available
         COMMENTS:       private function 
 */
 
-int8_t check_port_available(int8_t pt);
+int8_t check_port_available(uint8_t pt);
 /* 
 This function checks whether port 'pt' is available
@@ -100 +111 @@
 */ 
 
-void assign_port(int8_t pt);
-/*
-This functions records the fact that port 'pt' is allocated
-
-        PARAMS:         pt: port number to be allocated
+int8_t assign_port(Port *p, uint8_t pt);
+/*
+This functions records the fact that port 'pt' is allocated. It also creates and registers
+the two signals associated with the port
+
+        PARAMS:         p: pointer to the empty element within the 'Port' array
+                                        pt: port number to be allocated
+        RETURNS:                NRK_OK if the assignment is successful
+                                        NRK_ERROR otherwise
+        
+        ERROR NOS:      NO_SIGNALS_AVAILABLE if one of the two signals could not be created
+        COMMENTS:       private function
+        
+*/
+
+void release_port(Port *p);
+/*
+This functions records the fact that a given port number is now available
+
+        PARAMS:         p: Pointer to the port information
         RETURNS:                None
         COMMENTS:       private function
-        
-*/
-
-void release_port(int8_t port);
-/*
-This functions records the fact that 'port' is now available
-
-        PARAMS:         port: port number to be released
-        RETURNS:                None
-        COMMENTS:       None
+*/
+
+int8_t get_index_unassigned_port_element()
+/*
+This function returns the index of an unassigned port element if available
+        
+        PARAMS:         None
+        RETURNS:                the index or NRK_ERROR if none is available
+        
+        ERROR NOS:      NO_PORT_ELEMENT_AVAILABLE
+        Comments:       private function
+*/
+
+int8_t get_index_unassigned_rbm_element()
+/*
+This function returns the index of an unassigned rbm element if available 
+
+        PARAMS:         None
+        RETURNS:                the index or NRK_ERROR if none is available
+        
+        ERROR NOS:      NO_RBM_ELEMENT_AVAILABLE
+        Comments:       private function
 */
 
@@ -138 +176 @@
 */
 
-int8_t get_rx_queue_size(int8_t sock_num);
+int8_t get_rx_queue_size(int16_t sock_num);
 /*
 This function returns the size of the rx queue associated with a given socket descriptor
@@ -211 +249 @@
 */
 
-int8_t is_port_associated(int8_t port);
+int8_t is_port_associated(int16_t port);
 /*
 This function checks whether a given port number has been assigned to a socket or not 
                 
-                PARAMS: port: The port number
-                RETURNS: TRUE if a mapping exists, FALSE otherwise
+                PARAMS:         port: The port number
+                RETURNS:        TRUE if a mapping exists, FALSE if a mapping does not exist
+                                                NRK_ERROR if some error is encountered
+                                        
+                ERROR NOS:      INVALID_ARGUMENT when the passed parameter is faulty
                 COMMENTS: User API 
 */
 
-int8_t send(int8_t sock_num, uint8_t *ptr, int8_t len, int16_t dest_addr, int8_t dest_port, int8_t prio);
+int8_t send(int8_t sock_num, uint8_t *ptr, int8_t len, int32_t dest_addr, int8_t dest_port, int8_t prio);
 /*
 This function can be used by the application task to send data to other nodes on the network
@@ -266 +307 @@
 */ 
 
-uint8_t* receive(int8_t sock_num, int8_t *len, int8_t *srcAddr, int8_t *srcPort, int8_t *rssi);
+uint8_t* receive(int8_t sock_num, int8_t *len, uint16_t *srcAddr, uint8_t *srcPort, int8_t *rssi);
 /*
 This function allows an application to receive a message along with network control information

nano-RK/projects/network_stack/makefile

@@ -1 +1 @@
 # Platform name  cc2420DK, firefly, micaZ
-PLATFORM = firefly2_2
+PLATFORM = firefly2
 
 # Target file name (without extension).