Changeset 119

Timestamp:

06/28/2007 07:11:40 PM (5 years ago)

Author:

ayb

Message:

changed implementation of ports

Location:

nano-RK/projects/network_stack

Files:

• App.c (modified) (3 diffs)
• BufferManager.c (modified) (22 diffs)
• BufferManager.h (modified) (7 diffs)
• NWErrorCodes.h (modified) (1 diff)
• NetworkLayer.c (modified) (9 diffs)
• TransportLayerUDP.c (modified) (55 diffs)
• TransportLayerUDP.h (modified) (11 diffs)

nano-RK/projects/network_stack/App.c

@@ -45 +45 @@
   uint8_t *rx_buf;
   int8_t len;
-  int16_t srcAddr = 10;
-  int8_t srcPort;
+  uint16_t srcAddr = 10;
+  uint8_t srcPort;
   int8_t rssi;
   int8_t i;
@@ -118 +118 @@
                         
                         if(NODE_ADDR == 1)
+                        {
                                 if( send(sock, tx_buf, strlen(tx_buf), 2,  SERVER2_PORT, NORMAL_PRIORITY) == NRK_ERROR )        
                                 {
@@ -123 +124 @@
                                         flag = 1;
                                 }
+                        }
                         else
                                 if( send(sock, tx_buf, strlen(tx_buf), 1,  SERVER1_PORT, NORMAL_PRIORITY) == NRK_ERROR )

nano-RK/projects/network_stack/BufferManager.c

@@ -14 +14 @@
 #include "Debug.h"
 
+/***************************** External variables/ functions ************************/
+// From TransportLayerUDP.c
+extern Port ports[];
+
 /**************************** Global buffers required by all tasks ******************/
 
@@ -21 +25 @@
 TransmitBuffer tx_buf[MAX_TX_QUEUE_SIZE];                       // transmit queue for the entire system 
 
-ReceiveBufferManager rx_buf_mgr[MAX_PORTS + 1]; // create one receive manager per port
+ReceiveBufferManager rx_buf_mgr[MAX_PORTS];             // create one receive manager per port
                                                                                                                                 // port 0 is reserved 
 TransmitBufferManager tx_buf_mgr;                                       // one transmit manager for the whole system 
@@ -28 +32 @@
                                                                                                                                 // excess policy settings
                                                                                                                                 
-SendDoneSignal sd_sig[MAX_PORTS + 1];                           // create one send_done signal per port 
-
 nrk_sem_t *bm_sem;                                                                              // semaphore to access the above variables 
 
@@ -488 +490 @@
         {
                 rx_buf_mgr[i].pid = INVALID_PID;                        // pid of task associated with the port 
+                rx_buf_mgr[i].pindex = -1;                                      // indicates absence of rbm/port mapping 
                 rx_buf_mgr[i].head_fq = NULL;
                 rx_buf_mgr[i].tail_fq = NULL;
@@ -494 +497 @@
                 rx_buf_mgr[i].countTotal = 0;
                 rx_buf_mgr[i].countFree = 0;
-           rx_buf_mgr[i].seg_arrived_signal = nrk_signal_create();
-           sd_sig[i].send_done_signal = nrk_signal_create();
         }
         
@@ -536 +537 @@
                         return TRUE;
         }
-        return FALSE;
+        return FALSE; 
 }
 /*******************************************************************************************/
@@ -591 +592 @@
 }
 /**************************************************************************************/
+int8_t port_to_rbm_index(uint8_t port)
+{
+        int8_t i;       // loop index
+        
+        for(i = 0; i < MAX_PORTS; i++)
+                if(rx_buf_mgr[i].pindex != -1)  // valid rbm element 
+                        if(ports[rx_buf_mgr[i].pindex].pno == port)     // found the matching rbm element 
+                                return i;
+        
+        // if the code reaches here, it means no match was found
+        return NRK_ERROR;
+}
+/**************************************************************************************/
+int8_t port_to_port_index(uint8_t port)
+{
+        int8_t i;       // loop index
+        
+        for(i = 0; i < MAX_PORTS; i++)
+                if(ports[i].pno == port)        // match found
+                        return i;
+        
+        // if the code reaches here, it means no match was found
+        return NRK_ERROR;
+}
+/**************************************************************************************/
 void insert_rx_pq(Transport_Segment_UDP *seg, int8_t prio, uint16_t addr, int8_t rssi)
 {
-        int8_t port;                                                    // destination port of the segment
-        
-        //enter_cr(bm_sem, "insert_rx_pq()");
-         
-        port = seg -> destPort; 
-        ReceiveBufferUDP *buf = remove_rx_fq(port, EMPTY);              // remove an EMPTY buffer from the free queue
+        int8_t rbm_index;                                               // index of the corresponding rbm element 
+        
+        rbm_index = port_to_rbm_index(seg -> destPort); 
+        ReceiveBufferUDP *buf = remove_rx_fq(rbm_index, EMPTY);         // remove an EMPTY buffer from the free queue
         
         // pointers for traversing the port queue 
-        ReceiveBufferUDP *ptr = rx_buf_mgr[port].head_pq;                                
+        ReceiveBufferUDP *ptr = rx_buf_mgr[rbm_index].head_pq;                           
         ReceiveBufferUDP *prev = NULL; 
         
@@ -625 +649 @@
                 
                 if(prev == NULL)        // the newly received segment is to be inserted at the head of the port queue 
-                        rx_buf_mgr[port].head_pq = buf;
+                        rx_buf_mgr[rbm_index].head_pq = buf;
                 else
                         prev -> next = buf;
@@ -641 +665 @@
         
         // check for 2 
-        if(rx_buf_mgr[port].head_pq == NULL)
-        {
-                if(rx_buf_mgr[port].countFree != 0)     // debugging purposes 
+        if(rx_buf_mgr[rbm_index].head_pq == NULL)
+        {
+                if(rx_buf_mgr[rbm_index].countFree != 0)        // debugging purposes 
                 {
                         nrk_int_disable();
@@ -658 +682 @@
         // in the port queue has to be replaced   
         // check if the last segment in the port queue has a lower priority
-        if( (rx_buf_mgr[port].tail_pq) -> prio < prio ) // this last segment should be replaced
+        if( (rx_buf_mgr[rbm_index].tail_pq) -> prio < prio ) // this last segment should be replaced
         {
                 // at this point we know that ptr cannot be NULL                
                 // find the last but one segment in the port queue 
                 
-                ReceiveBufferUDP *qtr = rx_buf_mgr[port].head_pq;
+                ReceiveBufferUDP *qtr = rx_buf_mgr[rbm_index].head_pq;
                 // corner case, see if there is only one buffer in the port queue 
-                if(rx_buf_mgr[port].head_pq == rx_buf_mgr[port].tail_pq)
+                if(rx_buf_mgr[rbm_index].head_pq == rx_buf_mgr[rbm_index].tail_pq)
                 {
                         // replace the members of this last buffer with those of the new one 
@@ -682 +706 @@
                                 
                         // replace the members of the last buffer with those of the new one
-                        (rx_buf_mgr[port].tail_pq) -> seg = *seg;
-                        (rx_buf_mgr[port].tail_pq) -> prio = prio;
-                        (rx_buf_mgr[port].tail_pq) -> srcAddr = addr;
-                        (rx_buf_mgr[port].tail_pq) -> rssi = rssi;
+                        (rx_buf_mgr[rbm_index].tail_pq) -> seg = *seg;
+                        (rx_buf_mgr[rbm_index].tail_pq) -> prio = prio;
+                        (rx_buf_mgr[rbm_index].tail_pq) -> srcAddr = addr;
+                        (rx_buf_mgr[rbm_index].tail_pq) -> rssi = rssi;
                                 
                         // adjust the pointers so that this new segment occupies its correct position in the port queue                 
-                        (rx_buf_mgr[port].tail_pq) -> next = ptr;
+                        (rx_buf_mgr[rbm_index].tail_pq) -> next = ptr;
                         if(prev == NULL)
-                                rx_buf_mgr[port].head_pq = rx_buf_mgr[port].tail_pq;
+                                rx_buf_mgr[rbm_index].head_pq = rx_buf_mgr[rbm_index].tail_pq;
                         else
-                                prev -> next = rx_buf_mgr[port].tail_pq;
+                                prev -> next = rx_buf_mgr[rbm_index].tail_pq;
                                         
                         qtr -> next = NULL;                             
-                        rx_buf_mgr[port].tail_pq = qtr; // change the tail of the port queue
+                        rx_buf_mgr[rbm_index].tail_pq = qtr;    // change the tail of the port queue
                         
                         //leave_cr(bm_sem, "insert_rx_pq()");
@@ -701 +725 @@
                 }
         } // end if 
-        else if( (rx_buf_mgr[port].tail_pq) -> prio == prio )   
+        else if( (rx_buf_mgr[rbm_index].tail_pq) -> prio == prio )      
                   {
                                 // check the setting of the excess policy for this priority level 
@@ -707 +731 @@
                                 {
                                         // replace the members of the last buffer with those of the new one 
-                                        (rx_buf_mgr[port].tail_pq) -> seg = *seg;
-                                        (rx_buf_mgr[port].tail_pq) -> prio = prio;
-                                        (rx_buf_mgr[port].tail_pq) -> srcAddr = addr;
-                                        (rx_buf_mgr[port].tail_pq) -> rssi = rssi;
+                                        (rx_buf_mgr[rbm_index].tail_pq) -> seg = *seg;
+                                        (rx_buf_mgr[rbm_index].tail_pq) -> prio = prio;
+                                        (rx_buf_mgr[rbm_index].tail_pq) -> srcAddr = addr;
+                                        (rx_buf_mgr[rbm_index].tail_pq) -> rssi = rssi;
                                         
                                         //leave_cr(bm_sem, "insert_rx_pq()");
@@ -732 +756 @@
 }
 /*************************************************************************************************/
-ReceiveBufferUDP* remove_rx_pq(int8_t port)
+ReceiveBufferUDP* remove_rx_pq(int8_t rbm_index)
 {
         // The remove is always done from the head of the queue since its a priority queue      
@@ -739 +763 @@
         //enter_cr(bm_sem, "remove_rx_pq()");
                         
-        if(rx_buf_mgr[port].head_pq == NULL)    // no more queued segments
+        if(rx_buf_mgr[rbm_index].head_pq == NULL)       // no more queued segments
         {
                 //leave_cr(bm_sem, "remove_rx_pq()");
@@ -745 +769 @@
         }
                 
-        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(rx_buf_mgr[rbm_index].head_pq == rx_buf_mgr[rbm_index].tail_pq)      // only one buffer in queue 
+                rx_buf_mgr[rbm_index].tail_pq = NULL;
+                
+        ptr = rx_buf_mgr[rbm_index].head_pq;
+        
+        rx_buf_mgr[rbm_index].head_pq = rx_buf_mgr[rbm_index].head_pq -> next;
                 
         //leave_cr(bm_sem, "remove_rx_pq()");   
@@ -757 +781 @@
 /*************************************************************************************************/
 
-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 rbm_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[rbm_index].head_fq == NULL)       // the free queue is empty 
+        {
+                rx_buf_mgr[rbm_index].head_fq = rx_buf_mgr[rbm_index].tail_fq = buf;
                 buf -> next = NULL;
         }       
         else
         {
-                rx_buf_mgr[port].tail_fq -> next = buf;
+                rx_buf_mgr[rbm_index].tail_fq -> next = buf;
                 buf -> next = NULL;
-                rx_buf_mgr[port].tail_fq = buf;
+                rx_buf_mgr[rbm_index].tail_fq = buf;
         }
 
         if(status == EMPTY)     // this function was called from bind() / setReceiveQueueSize()
         {
-                rx_buf_mgr[port].countFree++;
+                rx_buf_mgr[rbm_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(int8_t rbm_index, int8_t status)
 {
         // This function removes the next receive buffer from the free queue having a given status      
@@ -791 +812 @@
         ReceiveBufferUDP *prev = NULL;
         
-        if(rx_buf_mgr[port].head_fq == NULL)    // no buffers remaining in free queue   
+        if(rx_buf_mgr[rbm_index].head_fq == NULL)       // no buffers remaining in free queue   
                 return NULL;
                 
-        ptr = rx_buf_mgr[port].head_fq;
+        ptr = rx_buf_mgr[rbm_index].head_fq;
         while(ptr != NULL)
         {
@@ -812 +833 @@
         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(rx_buf_mgr[rbm_index].head_fq == rx_buf_mgr[rbm_index].tail_fq)      // only one buffer in free queue
+                        rx_buf_mgr[rbm_index].tail_fq = NULL;
+                        
+                rx_buf_mgr[rbm_index].head_fq = rx_buf_mgr[rbm_index].head_fq -> next;
                 if(status == EMPTY)
-                        rx_buf_mgr[port].countFree--;
+                        rx_buf_mgr[rbm_index].countFree--;
                 return ptr;
         }
@@ -824 +845 @@
         prev -> next = ptr -> next;
         if(status == EMPTY)
-                rx_buf_mgr[port].countFree--;
+                rx_buf_mgr[rbm_index].countFree--;
         return ptr;
 }
@@ -940 +961 @@
 /**************************************************************************************************/
 
-int8_t get_in_process_buf_count(int8_t port)
+int8_t get_in_process_buf_count(int8_t rbm_index)
 {
         int8_t count = 0;
@@ -946 +967 @@
         //enter_cr(bm_sem, "get_in_process_buf_count()");
         
-        ReceiveBufferUDP *ptr = rx_buf_mgr[port].head_fq;
+        ReceiveBufferUDP *ptr = rx_buf_mgr[rbm_index].head_fq;
         
         while(ptr != NULL)

nano-RK/projects/network_stack/BufferManager.h

@@ -59 +59 @@
 typedef struct
 {
-        int8_t pid;                                                             // pid of task associated with the port 
+        int8_t pid;                                                             // pid of task associated with the port
+        int8_t pindex;                                                  // index of associated port element 
         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 
 
@@ -154 +153 @@
 */
 
+int8_t port_to_rbm_index(uint8_t port);
+/*
+This function finds the index of the rbm element corresponding to a given port number
+
+        PARAMS:         port: The port number
+        RETURNS:                the index of the rbm element if present or NRK_ERROR if no match is found 
+        Comments:       private function
+*/
+
 void insert_rx_pq(Transport_Segment_UDP *seg, int8_t prio, uint16_t addr, int8_t rssi);
 /*
@@ -168 +176 @@
 */
 
-ReceiveBufferUDP* remove_rx_pq(int8_t port);
+ReceiveBufferUDP* remove_rx_pq(int8_t rbm_index);
 /*
 This function removes the receive buffer at the head of a given port queue
 
-        PARAMS:         port: The port
+        PARAMS:         rbm_index: the index of the relevant receive buffer manager
         RETURNS:                pointer to the receive buffer or NULL if the port queue is empty 
         COMMENTS:       private function
 */ 
 
-void insert_rx_fq(ReceiveBufferUDP *buf, int8_t port, int8_t status);
+void insert_rx_fq(ReceiveBufferUDP *buf, int8_t rbm_index, int8_t status);
 /* 
 This function inserts a given receive buffer into the free queue of a given port
@@ -183 +191 @@
 
         PARAMS:         buf:    pointer to the receive buffer
-                                        port: the port number associated with the free queue
+                                        rbm_index: the index of the relevant receive buffer manager
                                         status: EMPTY or FULL
                                         
@@ -190 +198 @@
 */ 
 
-ReceiveBufferUDP* remove_rx_fq(uint8_t port, int8_t status);
+ReceiveBufferUDP* remove_rx_fq(int8_t rbm_index, int8_t status);
 /*
 This function removes a receive buffer from the free queue with the given status
 
-        PARAMS:         port: the port number associated with the free queue
+        PARAMS:         rbm_index: the index of the relevant receive buffer manager
                                         status: EMPTY or FULL
                                         
@@ -242 +250 @@
 */ 
 
-int8_t get_in_process_buf_count(int8_t port);
+int8_t get_in_process_buf_count(int8_t rbm_index);
 /*
 This function returns the number of FULL buffers in the free queue associated with a given port
 
-        PARAMS:         port: The port number
+        PARAMS:         rbm_index: the index of the relevant receive buffer manager
         RETURNS:                number of FULL buffers in the free queue 
         COMMENTS:       private function

nano-RK/projects/network_stack/NWErrorCodes.h

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

nano-RK/projects/network_stack/NetworkLayer.c

@@ -23 +23 @@
 // From TransportLayerUDP.c 
 extern nrk_sem_t *tl_sem;
-
-extern int8_t is_port_associated(int8_t);
+extern Port ports[];
+
+extern int8_t is_port_associated(int16_t port);
 
 //From BufferManager.c 
 extern nrk_sem_t *bm_sem;
-extern SendDoneSignal sd_sig[];
 extern ReceiveBufferManager rx_buf_mgr[];
 
-extern void insert_rx_queue(Transport_Segment_UDP *, uint8_t, uint8_t, int8_t);
 extern void insert_rx_pq(Transport_Segment_UDP*, int8_t, uint16_t, int8_t);
 extern TransmitBuffer* remove_tx_aq();
 extern void insert_tx_fq(TransmitBuffer*);
-extern void enter_cr(nrk_sem_t *, int8_t *);
-extern void leave_cr(nrk_sem_t *, int8_t *);
+extern void enter_cr(nrk_sem_t *, int8_t);
+extern void leave_cr(nrk_sem_t *, int8_t);
+extern int8_t port_to_port_index(uint8_t);
 
 
@@ -44 +44 @@
 extern void pack_NodeToGatewaySerial_Packet_header(uint8_t *, NodeToGatewaySerial_Packet *);
 extern void pack_TL_UDP_header(uint8_t *, Transport_Segment_UDP*);
+extern void pack_NW_Packet_header(uint8_t *,NW_Packet*); 
 
 extern void unpack_Msg_NgbList(Msg_NgbList*, uint8_t *);
@@ -267 +268 @@
                 // check to see if the destination port in the header is associated with any socket 
                 enter_cr(bm_sem, 28);
+                enter_cr(tl_sem, 28);
+                
                 if(is_port_associated(udp_seg.destPort) == TRUE)        // yes there is 
                 {
+                        int8_t port_index;
+                        
                         insert_rx_pq(&udp_seg, pkt -> prio, pkt -> src, rssi);
-                        nrk_event_signal(rx_buf_mgr[udp_seg.destPort].seg_arrived_signal);      // signal 'seg arrived' 
+                        
+                        port_index = port_to_port_index(udp_seg.destPort);
+                        if(port_index == NRK_ERROR)     //sanity check for debugging
+                        {
+                                nrk_int_disable();
+                                nrk_led_set(RED_LED);
+                                while(1)
+                                        nrk_kprintf(PSTR("process_app_pkt(): Bug detected in implementation of port/rbm element array\r\n"));
+                        }                       
+                        nrk_event_signal(ports[port_index].data_arrived_signal);        // signal 'data arrived' 
                 }
         
                 else // if there is no socket associated with this port, simply drop the packet
                         ;
-                        
+                leave_cr(tl_sem, 28);   
                 leave_cr(bm_sem, 28);
         }
@@ -381 +395 @@
         pkt_tx.prio = NORMAL_PRIORITY;
         
-        pack_Msg_NgbList(pkt_tx.data, m);
+        pack_Msg_Hello(pkt_tx.data, m);
         return;
 }
@@ -514 +528 @@
 void nl_tx_task()
 {
-        TransmitBuffer *ptr;                            // pointer to the buffer to be transmitted 
-        Transport_Segment_UDP *seg;     // temporary variable to retrieve the source port of the message 
-        nrk_sig_t tx_done_signal;               // to hold the tx_done signal from the link layer 
-        int8_t ret;                                                     // to hold the return value of various functions 
+        TransmitBuffer *ptr = NULL;                             // pointer to the buffer to be transmitted 
+        Transport_Segment_UDP *seg = NULL;         // temporary variable to retrieve the source port of the message 
+        nrk_sig_t tx_done_signal;                                       // to hold the tx_done signal from the link layer 
+        int8_t ret;                                                                             // to hold the return value of various functions 
+        int8_t port_index;                                                      // to store the index of the corresponding port element 
         
         //static Msg_NgbList mnlist;
@@ -548 +563 @@
                 } 
                         
-                if( pkt_type((ptr -> pkt).type) == APPLICATION )
+                if( pkt_type(&(ptr -> pkt)) == APPLICATION )
                 {               
                         // remove the encapsulated TL segment from the packet 
@@ -555 +570 @@
                         
                 // pack the network packet header into the transmit buffer 
-                pack_NW_Packet_header(tx_buf, ptr -> pkt);
+                pack_NW_Packet_header(tx_buf, &(ptr -> pkt));
                 // append the application payload into the transmit buffer
                 memcpy(tx_buf + SIZE_NW_PACKET_HEADER, (ptr -> pkt).data, (ptr -> pkt).length);
@@ -570 +585 @@
                 
                 ret = nrk_event_wait (SIG(tx_done_signal));
-           if(ret & SIG(tx_done_signal) == 0 ) 
+           if((ret & SIG(tx_done_signal)) == 0 ) 
                 {
                         nrk_int_disable();
@@ -579 +594 @@
                 // signal 'send done' signal 
                 enter_cr(bm_sem, 34);
-                nrk_event_signal(sd_sig[seg -> srcPort].send_done_signal);
+                enter_cr(tl_sem, 34);
+                port_index = port_to_port_index(seg -> srcPort);
+                nrk_event_signal(ports[port_index].send_done_signal);
+                leave_cr(tl_sem, 34);           
                 leave_cr(bm_sem, 34);
    }

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 bit vector representing the available ports                                                                                 
+Socket sock[MAX_PORTS];                         // array to store available socket descriptors 0 - (MAX_PORTS - 1)
+
+Port ports[MAX_PORTS];                          // array to store available port numbers (1 - MAX_PORT_NUM)
 
 int8_t tlayer_init_done;                        // flag to indicate whether initialization has been done correctly 
@@ -33 +32 @@
 
 extern void enter_cr(nrk_sem_t *, int8_t);
-extern void leave_cr(nrk_sem_t *, int8_t *);
+extern void leave_cr(nrk_sem_t *, int8_t);
 extern int8_t get_num_bufs_free();
 extern void insert_rx_fq(ReceiveBufferUDP*, int8_t, int8_t);
@@ -50 +49 @@
 {
         int8_t i;       // loop index 
-        // make all the socket descriptors unassigned 
+        
+        // make the socket descriptors and ports unassigned 
         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].pindex = -1;                                    // indicates the absence of socket-port mapping 
+                sock[i].rbmindex = -1;                          // 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 with priority ceiling equal to MAX_TASK_PRIORITY    
+        tl_sem = nrk_sem_create(1,MAX_TASK_PRIORITY);   
         if(tl_sem == NULL)
         {
@@ -75 +77 @@
 /**************************************************************************************************/
 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
@@ -122 +122 @@
         }
                 
-        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 
-{
-        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 
-                        return i;
-        }
+uint8_t get_next_available_port()
+{
+        uint16_t i;     // loop index for ephemeral port numbers
+        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' has been taken
+                                break;
+                                
+                if(j == MAX_PORTS)                      // port 'i' is free
+                        return i;                                       // return this ephemeral port number back
+        } 
+        
+        // if the code reaches there, it means that all ephemeral port numbers have been taken.
+        // This also means that the 'ports' array is full 
+         
         _nrk_errno_set(NO_PORTS_AVAILABLE);     
-        return NRK_ERROR;                                                        
+        return INVALID_PORT;                                                     
 }
 /******************************************************************************************/
-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 
+int8_t check_port_available(uint8_t pt)
+{
+        int8_t i;       // loop index
+        
+        for(i = 0; i < MAX_PORTS; i++)
+                if(ports[i].pno == pt)  // port 'pt' has been taken
+                        break;
+                        
+        if(i == MAX_PORTS)                      // port 'pt' is available 
                 return NRK_OK;
-        
+                
         _nrk_errno_set(PORT_UNAVAILABLE);       
         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'
+void assign_port(int8_t pindex, uint8_t pt)
+{
+        int8_t ret1, ret2;      
+        
+        // fill up the members of the port element
+        ports[pindex].pno = pt;
+        ports[pindex].send_done_signal = nrk_signal_create();
+        ports[pindex].data_arrived_signal = nrk_signal_create();
+        
+        if( ports[pindex].send_done_signal == NRK_ERROR )
+        {
+                nrk_int_disable();
+                nrk_led_set(RED_LED);
+                while(1)
+                        nrk_kprintf(PSTR("assign_port(): Error creating the send_done signal\r\n"));
+        }
+        
+        if( ports[pindex].data_arrived_signal == NRK_ERROR )
+        {
+                nrk_int_disable();
+                nrk_led_set(RED_LED);
+                while(1)
+                        nrk_kprintf(PSTR("assign_port(): Error creating the data_arrived signal\r\n"));
+        }
+        
+        ret1 = nrk_signal_register(ports[pindex].send_done_signal);
+        ret2 = nrk_signal_register(ports[pindex].data_arrived_signal);
+        
+        if(ret1 == NRK_ERROR)
+        {
+                nrk_int_disable();
+                nrk_led_set(RED_LED);
+                while(1)
+                        nrk_kprintf(PSTR("assign_port(): Error registering the 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 the data_arrived signal\r\n"));
+        }
+                
         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'
+void release_port(int8_t pindex)
+{
+        int8_t ret1, ret2;
+
+        // invalidate members of the port element 
+        ports[pindex].pno = INVALID_PID;
+        ret1 = nrk_signal_delete(ports[pindex].send_done_signal);
+        ret2 = nrk_signal_delete(ports[pindex].data_arrived_signal);
+        
+        if(ret1 == NRK_ERROR)
+        {
+                nrk_int_disable();
+                nrk_led_set(RED_LED);
+                while(1)
+                        nrk_kprintf(PSTR("assign_port(): Error creating the 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 creating the data_arrived signal\r\n"));
+        }       
+        
         return; 
 }
-
 /*****************************************************************************************/
-int8_t bind(int8_t sock_num, int8_t port)
-{
-        int8_t index;                                                   // stores the index of next available receive buffer                     
+int8_t get_index_unassigned_port_element()
+{
+        int8_t i;
+        
+        for(i = 0; i < MAX_PORTS; i++)
+                if(ports[i].pno == INVALID_PORT)
+                        return i;
+                        
+        _nrk_errno_set(NO_PORT_ELEMENT_AVAILABLE);
+        return NRK_ERROR;
+}
+/*******************************************************************************************/
+int8_t get_index_unassigned_rbm_element()
+{
+        int8_t i;
+        
+        for(i = 0; i < MAX_PORTS; i++)
+                if(rx_buf_mgr[i].pindex == -1)
+                        return i;
+                        
+        _nrk_errno_set(NO_RBM_ELEMENT_AVAILABLE);
+        return NRK_ERROR;
+}
+/*****************************************************************************************/
+uint8_t get_port_num(int8_t sock_num)
+{
+        // ERROR checking
+        if(sock_num < 0 || sock_num > MAX_PORTS)
+        {
+                _nrk_errno_set(INVALID_ARGUMENT);
+                return INVALID_PORT;
+        }
+        
+        if(sock[sock_num].pid != nrk_get_pid())
+        {
+                _nrk_errno_set(INVALID_SOCKET);
+                return INVALID_PORT;
+        }
+        
+        if(sock[sock_num].pindex == -1)
+        {
+                _nrk_errno_set(UNMAPPED_SOCKET);
+                return INVALID_PORT;
+        }
+        
+        return ports[sock[sock_num].pindex].pno;
+}
+
+/*****************************************************************************************/
+int8_t bind(int8_t sock_num, int16_t port)
+{
+        int8_t buf_index;                                               // stores the index of next available receive buffer
+        int8_t port_index;                                      // stores the index of the next unassigned port element
+        int8_t rbm_index;                                               // stores the index of the next unassigned rbm element                   
         int8_t i;                                                               // loop index 
         int8_t size;                                                    // size of receive queue allocated for this port 
@@ -195 +313 @@
                 _nrk_errno_set(INVALID_ARGUMENT);
                 
-                leave_cr(tl_sem, "bind()");     
-                leave_cr(bm_sem, "bind()");     
-                return NRK_ERROR;
-        }
-                
-        if(port <= 0 || port > 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;
+        }
+                
+        if(port <= 0 || port > MAX_PORT_NUM)                    // bad input 
+        {
+                _nrk_errno_set(INVALID_ARGUMENT);
+                
+                leave_cr(tl_sem, 8);    
+                leave_cr(bm_sem, 8);
                 return NRK_ERROR;
         }
@@ -213 +331 @@
                 _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].rbmindex != -1)                       // 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) == FALSE)        // 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
         } 
@@ -238 +356 @@
                 _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;
+        }
+        
+        if(sock[sock_num].pindex != -1)                                         // sanity check for debugging
+        {
+                nrk_int_disable();
+                nrk_led_set(RED_LED);
+                while(1)
+                        nrk_kprintf(PSTR("bind(): Bug detected in implementation of port / rbm element array\r\n"));
+        }
+        
+        // error checking complete. Begin processing                            
         size = DEFAULT_RX_QUEUE_SIZE;
         // at this point, we know that
@@ -249 +376 @@
         // 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 )
-        {
-                nrk_int_disable();
-                nrk_led_set(RED_LED);
-                while(1)
-                        nrk_kprintf(PSTR("bind(): Error while registering for seg_arrived_signal\r\n"));
-        }
+        // retrieve the indices of the elements
+        port_index = get_index_unassigned_port_element();
+        rbm_index = get_index_unassigned_rbm_element();
+        
+        if(port_index == NRK_ERROR || rbm_index == NRK_ERROR)   // sanity check for debugging 
+        {       
+                nrk_int_disable();
+                nrk_led_set(RED_LED);
+                while(1)
+                        nrk_kprintf(PSTR("bind(): Bug detected in implementation of port / rbm element array\r\n"));
+        }
+        
+        // fill up the members of the port element
+        assign_port(port_index, (uint8_t)port);
+        
+        // fill up the members of the socket descriptor
+        sock[sock_num].pindex = port_index;
+        sock[sock_num].rbmindex = rbm_index;
+        
+        // fill up the members of the rbm element
+        rx_buf_mgr[rbm_index].pindex = port_index;
+        rx_buf_mgr[rbm_index].pid = nrk_get_pid();
                 
         // 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();
@@ -274 +411 @@
                 }
                 
-                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_rx_fq(&rx_buf_udp[buf_index], rbm_index, EMPTY); // insert the buffer in the free queue of the port
+                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; 
 }
@@ -286 +423 @@
 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;
+        int8_t count;   // to store the count of total rx buffers set aside for the given socket 
         
         enter_cr(bm_sem, 9);    
@@ -311 +447 @@
         }
         
-        if(sock[sock_num].port == INVALID_PORT) // no socket operations were performed yet
+        if(sock[sock_num].pindex == -1) // no socket operations were performed yet
         {
                 leave_cr(tl_sem, 9);    
                 leave_cr(bm_sem, 9);    
-                return 0;
-        }
+                return 0;                                                       // hence return 0 
+        }
+        
+        if(sock[sock_num].rbmindex == -1) // sanity check for debugging
+        {
+                nrk_int_disable();
+                nrk_led_set(RED_LED);
+                while(1)
+                        nrk_kprintf(PSTR("get_rx_queue_size(): Bug detected in implementation of port/rbm element array\r\n"));
+        }       
                 
         // 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;
+        count = rx_buf_mgr[sock[sock_num].rbmindex].countTotal; 
         
         leave_cr(tl_sem, 9);    
@@ -330 +473 @@
 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  
+        
+        int8_t buf_index;        // stores the index of next unallocated receive buffer
+        int8_t port_index; // stores the index of the next unassigned port element
+        int8_t rbm_index;        // stores the index of the next unassigned rbm element  
                 
         enter_cr(bm_sem, 10);
@@ -366 +512 @@
         }
         
-        if(sock[sock_num].port == INVALID_PORT) // there is no port associated with this socket yet
+        if(sock[sock_num].pindex == -1)                         // 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);
@@ -385 +531 @@
            }
                 // 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 )
-                {
+                // retrieve the indices of the elements
+                port_index = get_index_unassigned_port_element();
+                rbm_index = get_index_unassigned_rbm_element();
+                
+                if(port_index == NRK_ERROR || rbm_index == NRK_ERROR)   // sanity check for debugging 
+                {       
                         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 detected in implementation of port / rbm element array\r\n"));
+                }
+                
+                // fill up the members of the port element
+                assign_port(port_index, port);
+                
+                // fill up the members of the socket descriptor
+                sock[sock_num].pindex = port_index;
+                sock[sock_num].rbmindex = rbm_index;
+                
+                // fill up the members of the rbm element
+                rx_buf_mgr[rbm_index].pindex = port_index;
+                rx_buf_mgr[rbm_index].pid = nrk_get_pid();
+        
+        } // end if(bind was 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
                 {
@@ -405 +563 @@
                         return size;
                 }
+                else // size > DEFAULT_RX_QUEUE_SIZE
+                        size -= DEFAULT_RX_QUEUE_SIZE;
         }
         
@@ -413 +573 @@
         // 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();
@@ -427 +584 @@
                                 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_rx_fq(&rx_buf_udp[buf_index], rbm_index, EMPTY); // insert the buffer in the free queue of the port
+                rx_buf_mgr[rbm_index].countTotal++; 
                 num_bufs_free--;                
         }
@@ -434 +591 @@
         leave_cr(tl_sem, 10);
         leave_cr(bm_sem, 10);
+        
+        if(flag == 0)   // bind was called earlier
+                return size + DEFAULT_RX_QUEUE_SIZE;    
+        
         return size;
 }
@@ -439 +600 @@
 int8_t release_buffer(int8_t sock_num, uint8_t *ptr)
 {
-        int8_t port;                                            // to store the port number associated with the socket
         ReceiveBufferUDP *buf;                  // pointer to traverse the buffer list of the free queue 
         
@@ -462 +622 @@
                 return NRK_ERROR;
         }
-        if(sock[sock_num].port == INVALID_PORT) // if no socket operation was performed earlier 
+        if(sock[sock_num].pindex == -1) // if no socket operation was performed earlier 
         {
                 _nrk_errno_set(INVALID_SOCKET);
@@ -470 +630 @@
                 return NRK_ERROR;
         }
-                
-        port = sock[sock_num].port;                               // retrieve the port number from the socket descriptor 
+        
+        if(sock[sock_num].rbmindex == -1)       // sanity check for debugging 
+        {
+                nrk_int_disable();
+                nrk_led_set(RED_LED);
+                while(1)
+                        nrk_kprintf(PSTR("release_buffer(): Bug discovered in implementation of port / rbm element array\r\n"));
+        }
         
         // check to see if the pointer passed is valid
-        buf = rx_buf_mgr[port].head_fq;
+        buf = rx_buf_mgr[sock[sock_num].rbmindex].head_fq;
         while(buf != NULL)
         {
@@ -491 +657 @@
                 
         buf -> status = EMPTY;          // mark the buffer as available now
-        rx_buf_mgr[port].countFree++; 
+        rx_buf_mgr[sock[sock_num].rbmindex].countFree++; 
         
         leave_cr(tl_sem, 11);   
@@ -500 +666 @@
 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 
                 
@@ -525 +690 @@
                 
         // 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].pindex != -1) // some operation was performed earlier with this socket 
+        {
+                if(sock[sock_num].rbmindex == -1)       // sanity check
                 {
                         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("close_socket(): Bug discovered in implementation of port /rbm element array\r\n"));
+                }               
                 // remove all the FULL buffers from the port queue                      
-                while( (ptr = remove_rx_pq(port)) != NULL )             
+                while( (ptr = remove_rx_pq(sock[sock_num].rbmindex)) != NULL )          
                         ptr -> status = UNALLOCATED;            
                         
                 // remove all the EMPTY buffers from the free queue             
-                while( (ptr = remove_rx_fq(port, EMPTY)) != NULL ) 
+                while( (ptr = remove_rx_fq(sock[sock_num].rbmindex, EMPTY)) != NULL ) 
                         ptr -> status = UNALLOCATED;
                         
                 // remove all the FULL buffers from the free queue              
-                while( (ptr = remove_rx_fq(port,FULL)) != NULL )
+                while( (ptr = remove_rx_fq(sock[sock_num].rbmindex,FULL)) != NULL )
                         ptr -> status = UNALLOCATED;
-                
-                release_port(port);
+                        
+                rx_buf_mgr[sock[sock_num].rbmindex].pid = INVALID_PID;
+                rx_buf_mgr[sock[sock_num].rbmindex].pindex = -1;
+                rx_buf_mgr[sock[sock_num].rbmindex].countTotal = 0;
+                rx_buf_mgr[sock[sock_num].rbmindex].countFree = 0;
+                
+                release_port(sock[sock_num].pindex);
         }  
         
-        sock[sock_num].port = INVALID_PORT;
+        sock[sock_num].pindex = -1;
+        sock[sock_num].rbmindex = -1;
         sock[sock_num].pid = INVALID_PID;
         
@@ -560 +728 @@
 }
 /************************************************************************************************/
-int8_t is_port_associated(int8_t port)
-{
+int8_t is_port_associated(int16_t port)
+{
+        // ERROR checking
+        if(port <= 0 || port > MAX_PORT_NUM)
+        {
+                _nrk_errno_set(INVALID_ARGUMENT);
+                return NRK_ERROR;
+        }
+                
         enter_cr(tl_sem, 13);
                 
-        if(check_port_available(port) == NRK_OK)
+        if(check_port_available((uint8_t)port) == NRK_OK)
         {
                 leave_cr(tl_sem, 13);
@@ -573 +748 @@
 }
 /************************************************************************************************/ 
-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 send(int8_t sock_num, uint8_t *ptr, int8_t len, int32_t dest_addr, int16_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);
         
-        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 
@@ -606 +774 @@
         }
                 
-        if(dest_addr < 0 || dest_port <= 0 || dest_port > MAX_PORTS)    // bad input 
+        if(dest_addr < 0 || dest_port <= 0 || dest_port > MAX_PORT_NUM) // bad input 
         {
                 _nrk_errno_set(INVALID_ARGUMENT);
@@ -634 +802 @@
                 
         /* 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 
+        if(sock[sock_num].pindex == -1) // this means that bind() / set_rx_queue_size() was 
+                                                                                                // not called earlier
+        {
+                int8_t buf_index, port_index, rbm_index; // indices for the various arrays
+                uint8_t port; 
+                
+                if(get_num_bufs_free() < DEFAULT_RX_QUEUE_SIZE) // no rx buffers left for this socket 
                 {
                         leave_cr(tl_sem, 14);
-                        leave_cr(bm_sem, 14);           
+                        leave_cr(bm_sem, 14);
+                        _nrk_errno_set(NO_RX_BUFFERS_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"));
-        }       
-                
+                // retrieve the indices of the elements
+                port_index = get_index_unassigned_port_element();
+                rbm_index = get_index_unassigned_rbm_element();
+                buf_index = get_index_unallocated_rx_buf();
+                
+                if(port_index == NRK_ERROR || rbm_index == NRK_ERROR)   // sanity check for debugging 
+                {       
+                        nrk_int_disable();
+                        nrk_led_set(RED_LED);
+                        while(1)
+                                nrk_kprintf(PSTR("send(): Bug detected in implementation of port / rbm element array\r\n"));
+                }
+                
+                if(buf_index == NRK_ERROR)      // sanity check for debugging
+                {
+                        nrk_int_disable();
+                        nrk_led_set(RED_LED);
+                        while(1)
+                                nrk_kprintf(PSTR("send(): Bug detected in implementation of num_bufs_free\r\n"));
+                }                       
+                // retrieve the next ephemeral port number
+                port = get_next_available_port();
+                                
+                // fill up the members of the port element
+                assign_port(port_index, port);
+                
+                // fill up the members of the socket descriptor
+                sock[sock_num].pindex = port_index;
+                sock[sock_num].rbmindex = rbm_index;
+                
+                // fill up the members of the rbm element
+                rx_buf_mgr[rbm_index].pindex = port_index;
+                rx_buf_mgr[rbm_index].pid = nrk_get_pid();
+                
+                // insert a rx buffer in the free queue 
+                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--;
+        
+        } //end if(bind was called earlier)
+        
         // prepare a UDP segment 
-        udp_seg.srcPort = port;
-        udp_seg.destPort = dest_port;
+        udp_seg.srcPort = ports[sock[sock_num].pindex].pno;
+        udp_seg.destPort = (uint8_t)dest_port;
         udp_seg.length = len;
         memcpy(udp_seg.data, ptr, len); // application payload already packed 
@@ -668 +864 @@
         // prepare a network packet     
         pkt.src = NODE_ADDR;
-        pkt.dest = dest_addr;
+        pkt.dest = (uint16_t)dest_addr;
         pkt.ttl = MAX_NETWORK_DIAMETER;
         pkt.type = UDP;
@@ -679 +875 @@
         
         if(DEBUG_TL == 2)
-                nrk_kprintf(PSTR("Inside send(). Before inserting packet in transmit queue\r\n"));
+                nrk_kprintf(PSTR("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"));
+                nrk_kprintf(PSTR("send(). After inserting packet in transmit queue\r\n"));
                 
         if(result == NRK_ERROR)
@@ -734 +930 @@
 }
 /*************************************************************************************************/
-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     
+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 
+        int8_t rbm_index;                               // to store the index of the corresponding receive buffer manager
+        int8_t port_index;                      // to store the index of the port element  
         
         enter_cr(bm_sem, 16);
@@ -754 +951 @@
         }
 
-        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].pindex == -1 )
         {
                 _nrk_errno_set(INVALID_SOCKET); // socket description not complete
@@ -763 +960 @@
         }
         
-        // error checking complete. Begin processing    
-        port = sock[sock_num].port;
+        if(sock[sock_num].rbmindex == -1)       // sanity check for debugging
+        {
+                nrk_int_disable();
+                nrk_led_set(RED_LED);
+                while(1)
+                        nrk_kprintf(PSTR("receive(): Bug detected in implementation of port/rbm element array\r\n"));
+        }
+        
+        // error checking complete. Begin processing 
+        rbm_index = sock[sock_num].rbmindex;    
+        port_index = sock[sock_num].pindex;
         if(sock[sock_num].timeout.secs == 0 && sock[sock_num].timeout.nano_secs == 0)
         {
@@ -772 +978 @@
                 
                 // 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(rx_buf_mgr[rbm_index].countFree == rx_buf_mgr[rbm_index].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", ports[rx_buf_mgr[rbm_index].pindex].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(ports[port_index].data_arrived_signal));   // block
                                 enter_cr(bm_sem, 16);
                                 enter_cr(tl_sem, 16);  
@@ -792 +998 @@
                                                 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(ports[port_index].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;
                         }
@@ -818 +1024 @@
                         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)
@@ -825 +1031 @@
                         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(rx_buf_mgr[rbm_index].countFree == rx_buf_mgr[rbm_index].countTotal) // no queued segments 
                 {
                         while(1)
@@ -834 +1040 @@
                                 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(ports[port_index].data_arrived_signal) | SIG(nrk_wakeup_signal));
                                 enter_cr(bm_sem, 16);
                                 enter_cr(tl_sem, 16);                                    
@@ -846 +1052 @@
                                                 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(ports[port_index].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
+                                        nrk_kprintf(PSTR("Received the data arrived signal\r\n"));
                                 break;
                         }
@@ -860 +1065 @@
                                 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);
                                 
@@ -883 +1088 @@
    // In either case, retrieve the segment and return back to user task 
    
-   buf = remove_rx_pq(port);    // remove the buffer from the port queue 
+   buf = remove_rx_pq(rbm_index);       // remove the buffer from the port queue 
    if(buf == NULL)      // this should not happen 
    {
@@ -889 +1094 @@
                 nrk_led_set(RED_LED);
                 while(1)
-                        nrk_kprintf(PSTR("receive(): Bug found in implementation of seg_arrived_signal / rx buffer mgmt\r\n"));
-        }
-   insert_rx_fq(buf, port, FULL);       // insert the buffer into the free queue with status = FULL 
+                        nrk_kprintf(PSTR("receive(): Bug found in implementation of data_arrived_signal / rx buffer mgmt\r\n"));
+        }
+   insert_rx_fq(buf, rbm_index, FULL);  // insert the buffer into the free queue with status = FULL 
    seg = &(buf -> seg);
    
@@ -911 +1116 @@
 int8_t check_receive_queue(int8_t sock_num)
 {
-        int8_t port;
+        int8_t rbm_index;                       // to store the index of rbm element associated with the socket 
         int8_t count1, count2, count3;
         
@@ -917 +1122 @@
         enter_cr(tl_sem, 17);
         
-        
         // ERROR checking
         if(sock_num < 0 || sock_num >= MAX_PORTS)               // bad input 
@@ -928 +1132 @@
         }
 
-        if( (sock[sock_num].pid != nrk_get_pid()) || (sock[sock_num].port == INVALID_PORT) ) // wrong socket number 
+        if( (sock[sock_num].pid != nrk_get_pid()) || (sock[sock_num].pindex == -1) ) // wrong socket number 
         {
                 _nrk_errno_set(INVALID_SOCKET);
@@ -937 +1141 @@
         }
         
-        port = sock[sock_num].port;
-        count1 = rx_buf_mgr[port].countTotal;
-        count2 = rx_buf_mgr[port].countFree;
-        count3 = get_in_process_buf_count(port);
+        rbm_index = sock[sock_num].rbmindex;
+        count1 = rx_buf_mgr[rbm_index].countTotal;
+        count2 = rx_buf_mgr[rbm_index].countFree;
+        count3 = get_in_process_buf_count(rbm_index);
         
         leave_cr(tl_sem, 17);
@@ -949 +1153 @@
 int8_t wait_until_send_done(int8_t sock_num)
 {
-        int8_t port;                            // to hold the port number associated with the given socket number 
+        int8_t port_index;              // to store the index of the port element associated with the socket    
         nrk_sig_mask_t my_sigs; // temp variable 
         
@@ -965 +1169 @@
         }
         
-        if( (sock[sock_num].pid != nrk_get_pid()) || (sock[sock_num].port == INVALID_PORT) ) // bad socket 
+        if( (sock[sock_num].pid != nrk_get_pid()) || (sock[sock_num].pindex == -1) ) // bad socket 
         {
                 _nrk_errno_set(INVALID_SOCKET);
@@ -974 +1178 @@
         }
         
-        port = sock[sock_num].port;
+        // error checking complete. Begin processing 
+        
+        port_index = sock[sock_num].pindex;
         
         if(sock[sock_num].timeout.secs == 0 && sock[sock_num].timeout.nano_secs == 0)
@@ -983 +1189 @@
                         leave_cr(tl_sem, 18);
                         leave_cr(bm_sem, 18);                   
-                        my_sigs = nrk_event_wait( SIG(sd_sig[port].send_done_signal) );
+                        my_sigs = nrk_event_wait( SIG(ports[port_index].send_done_signal) );
                         enter_cr(bm_sem, 18);
                         enter_cr(tl_sem, 18);
@@ -995 +1201 @@
                         }
                         
-                        if( my_sigs & SIG(sd_sig[port].send_done_signal) )
+                        if( my_sigs & SIG(ports[port_index].send_done_signal) ) // data sent 
                         {
                                 leave_cr(tl_sem, 18);
@@ -1031 +1237 @@
                         leave_cr(tl_sem, 18);
                         leave_cr(bm_sem, 18);                   
-                        my_sigs = nrk_event_wait( SIG(sd_sig[port].send_done_signal) | SIG(nrk_wakeup_signal) );
+                        my_sigs = nrk_event_wait( SIG(ports[port_index].send_done_signal) | SIG(nrk_wakeup_signal) );
                         enter_cr(bm_sem, 18);
                         enter_cr(tl_sem, 18);
@@ -1040 +1246 @@
                                 nrk_led_set(RED_LED);
                                 while(1)
-                                        nrk_kprintf(PSTR("wait_until_send_done(): Error returned by nrk_event_wait() (with timeout)\r\n"));
+                                        nrk_kprintf(PSTR("wait_until_send_done(): Error returned by nrk_event_wait()\r\n"));
                         }
                                 
-                        if( my_sigs & SIG(sd_sig[port].send_done_signal) )
+                        if( my_sigs & SIG(ports[port_index].send_done_signal) )
                         {
                                 sock[sock_num].timeout.secs = 0;                        // disable the timeout 
@@ -1055 +1261 @@
                         if( my_sigs & SIG(nrk_wakeup_signal) )
                         {
-                                sock[sock_num].timeout.secs = 0;
+                                sock[sock_num].timeout.secs = 0;                        // disable the timeout 
                                 sock[sock_num].timeout.nano_secs = 0; 
                                 _nrk_errno_set(SOCKET_TIMEOUT);

nano-RK/projects/network_stack/TransportLayerUDP.h

@@ -20 +20 @@
 
 #define EPHEMERAL_PORT_NUM_START 11             // 11 is the smallest port number available to user tasks
+#define MAX_PORT_NUM 255
 
 // limits on various object types 
@@ -32 +33 @@
 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 
@@ -39 +40 @@
 }Transport_Segment_UDP;
 
+typedef struct 
+{
+        uint8_t pno;                                                    // the actual port number 
+        nrk_sig_t data_arrived_signal;  // indicates that data has arrived for this port in the receive queue 
+        nrk_sig_t send_done_signal;             // indicates that the highest priority message from this port 
+                                                                                                // has been sent over the radio 
+}Port;
+
 typedef struct
 {
-        int8_t port;                                                    // port number associated with this socket descriptor 
+        int8_t pindex;                                                  // index of the port element for this socket
+        int8_t rbmindex;                                                // index of the rbm element for this socket      
         int8_t pid;                                                             // pid of the process holding this socket descriptor
         int8_t type;                                                    // type of socket
@@ -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, 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 +110 @@
 */ 
 
-void assign_port(int8_t pt);
+void assign_port(int8_t pindex, uint8_t pt);
 /*
 This functions records the fact that port 'pt' is allocated
 
-        PARAMS:         pt: port number to be allocated
+        PARAMS:         pindex: index of the relevant port element
+                                        pt: port number to be allocated
         RETURNS:                None
         COMMENTS:       private function
@@ -110 +121 @@
 */
 
-void release_port(int8_t port);
-/*
-This functions records the fact that 'port' is now available
-
-        PARAMS:         port: port number to be released
+void release_port(int8_t pindex);
+/*
+This functions records the fact that a given port is now available
+
+        PARAMS:         pindex: port element holding information about the port
         RETURNS:                None
-        COMMENTS:       None
-*/
-
-int8_t bind(int8_t sock_num, int8_t port);
+        COMMENTS:       private function
+*/
+
+int8_t get_unassigned_port_element();
+/*
+This function returns the index an unassigned port element or NRK_ERROR if none are available
+
+        PARAMS:         None
+        RETURNS:                index of an unassigned port element or NRK_ERROR if none are available
+        
+        ERROR NOS:      NO_PORT_ELEMENT_AVAILABLE
+        Comments:       private function
+*/
+
+int8_t get_unassigned_rbm_element();
+/*
+This function returns the index an unassigned rbm element or NRK_ERROR if none are available
+
+        PARAMS:         None
+        RETURNS:                index of an unassigned rbm element or NRK_ERROR if none are available
+        
+        ERROR NOS:      NO_RBM_ELEMENT_AVAILABLE
+        Comments:       private function
+*/
+
+uint8_t get_port_num(int8_t sock_num);
+/*
+This function can be used by an application to find the port number mapped to a given socket descriptor
+
+        PARAMS:         sock_num: The socket descriptor
+        RETURNS:                the corresponding port number or INVALID_PORT if none exists / error
+        
+        ERROR NOS:      INVALID_ARGUMENT if the passed parameter is faulty
+                                        INVALID_SOCKET if a wrong socket number is passed
+                                        UNMAPPED_SOCKET if no socket/port mapping exists
+                                        
+        Comments:       User API
+                                        A return value of INVALID_PORT could mean either an error has occurred or there 
+                                        does not exist any socket/port mapping. Check the error number to find out.
+*/ 
+
+int8_t bind(int8_t sock_num, int16_t port);
 /*
 This function binds a given socket descriptor to a given port number
@@ -177 +226 @@
                                         2. a valid port
                                         3. a receive queue of size at least 1
+                                        
 */ 
 
@@ -193 +243 @@
                                         
         COMMENTS:       User API
-                                        This function should be called when the application has finsihed processing
+                                        This function should be called when the application has finished processing
                                         a received message or has copied the message to a application-local storage 
                                         area
@@ -211 +261 @@
 */
 
-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
-                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);
+                PARAMS:         port: The port number
+                RETURNS:        TRUE if a mapping exists, FALSE if a mapping does not exist, NRK_ERROR on error
+                
+                ERROR NOS:      INVALID_ARGUMENT if the passed paramter is faulty               
+                COMMENTS:       User API 
+*/
+
+int8_t send(int8_t sock_num, uint8_t *ptr, int8_t len, int32_t dest_addr, int16_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 +318 @@
 */ 
 
-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
@@ -326 +378 @@
         
         ERROR NOS:      INVALID_ARGUMENT if the passed parameter is faulty
-                                        INVALID_SOCKET if an incomplete socket number is passed
+                                        INVALID_SOCKET if an incomplete socket descriptor is passed
                                         SOCKET_TIMEOUT if a timeout value is specified prior to this call and 
                                         the timeout value expires
         Comments:       User API
                                         If you want to specify a maximum wait period, use set_timeout() prior to every such
-                                        wait_until_send_done() call.  
+                                        wait_until_send_done() call. The return value of NRK_ERROR could mean either that an 
+                                        error occured during processing or that the timeout expired. Check the error number
+                                        to find out
 */