X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;f=src%2Frmr%2Fnng%2Fsrc%2Frmr_nng.c;h=1b6e1f0458891fa8204f0addbbc78eae7d8a5ea7;hb=6511ac74cdc367a94bffeb3743624775acd52c5b;hp=cf5e4295308af24a48164c3bf533f874681473a0;hpb=750cbee6b224532fc10971c04df556ce4bceb832;p=ric-plt%2Flib%2Frmr.git

diff --git a/src/rmr/nng/src/rmr_nng.c b/src/rmr/nng/src/rmr_nng.c
index cf5e429..1b6e1f0 100644
--- a/src/rmr/nng/src/rmr_nng.c
+++ b/src/rmr/nng/src/rmr_nng.c
@@ -254,6 +254,7 @@ extern rmr_mbuf_t*  rmr_rts_msg( void* vctx, rmr_mbuf_t* msg ) {
 		errno = EINVAL;												// if msg is null, this is their clue
 		if( msg != NULL ) {
 			msg->state = RMR_ERR_BADARG;
+			msg->tp_state = errno;
 		}
 		return msg;
 	}
@@ -262,6 +263,7 @@ extern rmr_mbuf_t*  rmr_rts_msg( void* vctx, rmr_mbuf_t* msg ) {
 	if( msg->header == NULL ) {
 		fprintf( stderr, "[ERR] rmr_send_msg: message had no header\n" );
 		msg->state = RMR_ERR_NOHDR;
+		msg->tp_state = errno;
 		return msg;
 	}
 
@@ -345,6 +347,7 @@ extern rmr_mbuf_t* rmr_call( void* vctx, rmr_mbuf_t* msg ) {
 		if( msg->state != RMR_ERR_RETRY ) {
 			msg->state = RMR_ERR_CALLFAILED;		// errno not available to all wrappers; don't stomp if marked retry
 		}
+		msg->tp_state = errno;
 		return msg;
 	}
 
@@ -365,10 +368,11 @@ extern rmr_mbuf_t* rmr_rcv_msg( void* vctx, rmr_mbuf_t* old_msg ) {
 	rmr_mbuf_t*	qm;				// message that was queued on the ring
 
 	if( (ctx = (uta_ctx_t *) vctx) == NULL ) {
+		errno = EINVAL;
 		if( old_msg != NULL ) {
 			old_msg->state = RMR_ERR_BADARG;
+			old_msg->tp_state = errno;
 		}
-		errno = EINVAL;
 		return old_msg;
 	}
 	errno = 0;
@@ -402,10 +406,11 @@ extern rmr_mbuf_t* rmr_torcv_msg( void* vctx, rmr_mbuf_t* old_msg, int ms_to ) {
 	rmr_mbuf_t* msg;
 
 	if( (ctx = (uta_ctx_t *) vctx) == NULL ) {
+		errno = EINVAL;
 		if( old_msg != NULL ) {
 			old_msg->state = RMR_ERR_BADARG;
+			old_msg->tp_state = errno;
 		}
-		errno = EINVAL;
 		return old_msg;
 	}
 
@@ -457,6 +462,7 @@ extern rmr_mbuf_t* rmr_torcv_msg( void* vctx, rmr_mbuf_t* old_msg, int ms_to ) {
 	nready = epoll_wait( eps->ep_fd, eps->events, 1, ms_to );     // block until something or timedout
 	if( nready <= 0 ) {						// we only wait on ours, so we assume ready means it's ours
 		msg->state = RMR_ERR_TIMEOUT;
+		msg->tp_state = errno;
 	} else {
 		return rcv_msg( ctx, msg );								// receive it and return it
 	}
@@ -480,10 +486,11 @@ extern rmr_mbuf_t* rmr_rcv_specific( void* vctx, rmr_mbuf_t* msg, char* expect,
 	int	exp_len = 0;			// length of expected ID
 
 	if( (ctx = (uta_ctx_t *) vctx) == NULL ) {
+		errno = EINVAL;
 		if( msg != NULL ) {
 			msg->state = RMR_ERR_BADARG;
+			msg->tp_state = errno;
 		}
-		errno = EINVAL;
 		return msg;
 	}
 
@@ -524,17 +531,15 @@ extern rmr_mbuf_t* rmr_rcv_specific( void* vctx, rmr_mbuf_t* msg, char* expect,
 	return NULL;
 }
 
-//  CAUTION:  these are not supported as they must be set differently (between create and open) in NNG.
-//				until those details are worked out, these generate a warning.
 /*
-	Set send timeout. The value time is assumed to be microseconds.  The timeout is the
-	rough maximum amount of time that RMr will block on a send attempt when the underlying
+	Set send timeout. The value time is assumed to be milliseconds.  The timeout is the
+	_rough_ maximum amount of time that RMr will block on a send attempt when the underlying
 	mechnism indicates eagain or etimeedout.  All other error conditions are reported
 	without this delay. Setting a timeout of 0 causes no retries to be attempted in
-	RMr code. Setting a timeout of 1 causes RMr to spin up to 10K retries before returning,
-	but without issuing a sleep.  If timeout is > 1, then RMr will issue a sleep (1us)
-	after every 10K send attempts until the time value is reached. Retries are abandoned
-	if NNG returns anything other than NNG_AGAIN or NNG_TIMEDOUT.
+	RMr code. Setting a timeout of 1 causes RMr to spin up to 1K retries before returning,
+	but _without_ issuing a sleep.  If timeout is > 1, then RMr will issue a sleep (1us)
+	after every 1K send attempts until the "time" value is reached. Retries are abandoned
+	if NNG returns anything other than NNG_EAGAIN or NNG_ETIMEDOUT.
 
 	The default, if this function is not used, is 1; meaning that RMr will retry, but will
 	not enter a sleep.  In all cases the caller should check the status in the message returned
@@ -559,6 +564,8 @@ extern int rmr_set_stimeout( void* vctx, int time ) {
 
 /*
 	Set receive timeout -- not supported in nng implementation
+
+	CAUTION:  this is not supported as they must be set differently (between create and open) in NNG.
 */
 extern int rmr_set_rtimeout( void* vctx, int time ) {
 	fprintf( stderr, "[WRN] Current implementation of RMR ontop of NNG does not support setting a receive timeout\n" );
@@ -670,6 +677,11 @@ static void* init(  char* uproto_port, int max_msg_size, int flags ) {
 	}
 	if( DEBUG ) fprintf( stderr, "[DBUG] default ip address: %s\n", ctx->my_ip );
 
+	if( (tok = getenv( ENV_WARNINGS )) != NULL ) {
+		if( *tok == '1' ) {
+			ctx->flags |= CTXFL_WARN;					// turn on some warnings (not all, just ones that shouldn't impact performance)
+		}
+	}
 
 
 	if( (interface = getenv( ENV_BIND_IF )) == NULL ) {
@@ -827,6 +839,7 @@ extern rmr_mbuf_t* rmr_mt_rcv( void* vctx, rmr_mbuf_t* mbuf, int max_wait ) {
 		errno = EINVAL;
 		if( mbuf ) {
 			mbuf->state = RMR_ERR_BADARG;
+			mbuf->tp_state = errno;
 		}
 		return mbuf;
 	}
@@ -835,6 +848,7 @@ extern rmr_mbuf_t* rmr_mt_rcv( void* vctx, rmr_mbuf_t* mbuf, int max_wait ) {
 		errno = EINVAL;
 		if( mbuf != NULL ) {
 			mbuf->state = RMR_ERR_NOTSUPP;
+			mbuf->tp_state = errno;
 		}
 		return mbuf;
 	}
@@ -868,6 +882,7 @@ extern rmr_mbuf_t* rmr_mt_rcv( void* vctx, rmr_mbuf_t* mbuf, int max_wait ) {
 	}
 
 	errno = 0;
+	state = 0;
 	while( chute->mbuf == NULL && ! errno ) {
 		if( seconds ) {
 			state = sem_timedwait( &chute->barrier, &ts );				// wait for msg or timeout
@@ -897,6 +912,9 @@ extern rmr_mbuf_t* rmr_mt_rcv( void* vctx, rmr_mbuf_t* mbuf, int max_wait ) {
 		}
 	}
 
+	if( mbuf ) {
+		mbuf->tp_state = errno;
+	}
 	return mbuf;
 }
 
@@ -928,9 +946,10 @@ extern rmr_mbuf_t* rmr_mt_call( void* vctx, rmr_mbuf_t* mbuf, int call_id, int m
 	long	nano_sec;			// max wait xlated to nano seconds
 	int		state;
 	
+	errno = EINVAL;
 	if( (ctx = (uta_ctx_t *) vctx) == NULL || mbuf == NULL ) {
-		errno = EINVAL;
 		if( mbuf ) {
+			mbuf->tp_state = errno;
 			mbuf->state = RMR_ERR_BADARG;
 		}
 		return mbuf;
@@ -938,11 +957,13 @@ extern rmr_mbuf_t* rmr_mt_call( void* vctx, rmr_mbuf_t* mbuf, int call_id, int m
 
 	if( ! (ctx->flags & CFL_MTC_ENABLED) ) {
 		mbuf->state = RMR_ERR_NOTSUPP;
+		mbuf->tp_state = errno;
 		return mbuf;
 	}
 
 	if( call_id > MAX_CALL_ID || call_id < 2 ) {					// 0 and 1 are reserved; user app cannot supply them
 		mbuf->state = RMR_ERR_BADARG;
+		mbuf->tp_state = errno;
 		return mbuf;
 	}
 
@@ -984,10 +1005,12 @@ extern rmr_mbuf_t* rmr_mt_call( void* vctx, rmr_mbuf_t* mbuf, int call_id, int m
 	mbuf = mtosend_msg( ctx, mbuf, 0 );						// use internal function so as not to strip call-id; should be nil on success!
 	if( mbuf ) {
 		if( mbuf->state != RMR_OK ) {
+			mbuf->tp_state = errno;
 			return mbuf;									// timeout or unable to connect or no endpoint are most likely issues
 		}
 	}
 
+	state = 0;
 	errno = 0;
 	while( chute->mbuf == NULL && ! errno ) {
 		if( seconds ) {