Prevent unneeded usleep after send retries

[ric-plt/lib/rmr.git] / src / rmr / nng / src / sr_nng_static.c

diff --git a/src/rmr/nng/src/sr_nng_static.c b/src/rmr/nng/src/sr_nng_static.c
index da4dfbd..79e6793 100644 (file)
--- a/src/rmr/nng/src/sr_nng_static.c
+++ b/src/rmr/nng/src/sr_nng_static.c
@@ -153,7 +153,8 @@ static rmr_mbuf_t* alloc_zcmsg( uta_ctx_t* ctx, rmr_mbuf_t* msg, int size, int s
        msg->xaction = ((uta_mhdr_t *)msg->header)->xid;                // point at transaction id in header area
        msg->state = state;                                                                             // fill in caller's state (likely the state of the last operation)
        msg->flags |= MFL_ZEROCOPY;                                                             // this is a zerocopy sendable message
-       strncpy( (char *) ((uta_mhdr_t *)msg->header)->src, ctx->my_name, RMR_MAX_SID );
+       strncpy( (char *) ((uta_mhdr_t *)msg->header)->src, ctx->my_name, RMR_MAX_SRC );
+       strncpy( (char *) ((uta_mhdr_t *)msg->header)->srcip, ctx->my_ip, RMR_MAX_SRC );
 
        if( DEBUG > 1 ) fprintf( stderr, "[DBUG] alloc_zcmsg mlen=%ld size=%d mpl=%d flags=%02x\n", (long) mlen, size, ctx->max_plen, msg->flags );
 
@@ -206,7 +207,7 @@ static rmr_mbuf_t* alloc_mbuf( uta_ctx_t* ctx, int state ) {
        is somewhat based on header version.
 */
 static void ref_tpbuf( rmr_mbuf_t* msg, size_t alen )  {
-       uta_mhdr_t* hdr;                                // current header
+       uta_mhdr_t* hdr = NULL;                 // current header
        uta_v1mhdr_t* v1hdr;                    // version 1 header
        int ver;
        int     hlen;                                           // header len to use for a truncation check
@@ -249,7 +250,7 @@ static void ref_tpbuf( rmr_mbuf_t* msg, size_t alen )  {
                        break;
        }
 
-       if( msg->len > (msg->alloc_len - hlen ) ) {                                             // more than we should have had room for; error
+       if( msg->len > (msg->alloc_len - hlen ) ) {
                msg->state = RMR_ERR_TRUNC;
                msg->len = msg->alloc_len -  hlen;                                                      // adjust len down so user app doesn't overrun
        } else {
@@ -513,7 +514,7 @@ static rmr_mbuf_t* send_msg( uta_ctx_t* ctx, rmr_mbuf_t* msg, nng_socket nn_sock
        int state;
        uta_mhdr_t*     hdr;
        int nng_flags = NNG_FLAG_NONBLOCK;              // if we need to set any nng flags (zc buffer) add it to this
-       int spin_retries = 1000;                                // if eagain/timeout we'll spin this many times before giving up the CPU
+       int spin_retries = 1000;                                // if eagain/timeout we'll spin, at max, this many times before giving up the CPU
        int     tr_len;                                                         // trace len in sending message so we alloc new message with same trace size
 
        // future: ensure that application did not overrun the XID buffer; last byte must be 0
@@ -525,7 +526,8 @@ static rmr_mbuf_t* send_msg( uta_ctx_t* ctx, rmr_mbuf_t* msg, nng_socket nn_sock
        tr_len = RMR_TR_LEN( hdr );                                                                             // snarf trace len before sending as hdr is invalid after send
 
        if( msg->flags & MFL_ADDSRC ) {                                                                 // buffer was allocated as a receive buffer; must add our source
-               strncpy( (char *) ((uta_mhdr_t *)msg->header)->src, ctx->my_name, RMR_MAX_SID );                                        // must overlay the source to be ours
+               strncpy( (char *) ((uta_mhdr_t *)msg->header)->src, ctx->my_name, RMR_MAX_SRC );                                        // must overlay the source to be ours
+               strncpy( (char *) ((uta_mhdr_t *)msg->header)->srcip, ctx->my_ip, RMR_MAX_SRC );
        }
 
        errno = 0;
@@ -537,7 +539,9 @@ static rmr_mbuf_t* send_msg( uta_ctx_t* ctx, rmr_mbuf_t* msg, nng_socket nn_sock
                                if( retries > 0 && (state == NNG_EAGAIN || state == NNG_ETIMEDOUT) ) {
                                        if( --spin_retries <= 0 ) {                     // don't give up the processor if we don't have to
                                                retries--;
-                                               usleep( 1 );                                    // sigh, give up the cpu and hope it's just 1 miscrosec
+                                               if( retries > 0 ) {                                     // only if we'll loop through again
+                                                       usleep( 1 );                                    // sigh, give up the cpu and hope it's just 1 miscrosec
+                                               }
                                                spin_retries = 1000;
                                        }
                                } else {