X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;f=src%2Frmr%2Fnng%2Fsrc%2Frmr_nng.c;h=bc3fe107cba3a476cbc35e70a04ea10ffe6e2f3b;hb=refs%2Fchanges%2F78%2F878%2F2;hp=8a91544c448c37f9a413ae315ebf4040c08e469a;hpb=68d09fa5028e47e763c44c30647da31e77eda64a;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 8a91544..bc3fe10 100644
--- a/src/rmr/nng/src/rmr_nng.c
+++ b/src/rmr/nng/src/rmr_nng.c
@@ -248,12 +248,14 @@ extern rmr_mbuf_t*  rmr_rts_msg( void* vctx, rmr_mbuf_t* msg ) {
 	uta_ctx_t*	ctx;
 	int			state;
 	char*		hold_src;			// we need the original source if send fails
+	char*		hold_ip;			// also must hold original ip
 	int			sock_ok = 0;		// true if we found a valid endpoint socket
 
 	if( (ctx = (uta_ctx_t *) vctx) == NULL || msg == NULL ) {		// bad stuff, bail fast
 		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,15 +264,17 @@ 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;
 	}
 
 	((uta_mhdr_t *) msg->header)->flags &= ~HFL_CALL_MSG;			// must ensure call flag is off
-	if( HDR_VERSION( msg->header ) > 2 ) {							// new version uses sender's ip address for rts
-		sock_ok = uta_epsock_byname( ctx->rtable, (char *) ((uta_mhdr_t *)msg->header)->srcip, &nn_sock );			// default to IP based rts
-	}
+
+	sock_ok = uta_epsock_byname( ctx->rtable, (char *) ((uta_mhdr_t *)msg->header)->src, &nn_sock );			// src is always used first for rts
 	if( ! sock_ok ) {
-		sock_ok = uta_epsock_byname( ctx->rtable, (char *) ((uta_mhdr_t *)msg->header)->src, &nn_sock );		// IP  not in rt, try name
+		if( HDR_VERSION( msg->header ) > 2 ) {							// with ver2 the ip is there, try if src name not known
+			sock_ok = uta_epsock_byname( ctx->rtable, (char *) ((uta_mhdr_t *)msg->header)->srcip, &nn_sock );
+		}
 		if( ! sock_ok ) {
 			msg->state = RMR_ERR_NOENDPT;
 			return msg;																// preallocated msg can be reused since not given back to nn
@@ -279,14 +283,17 @@ extern rmr_mbuf_t*  rmr_rts_msg( void* vctx, rmr_mbuf_t* msg ) {
 
 	msg->state = RMR_OK;																// ensure it is clear before send
 	hold_src = strdup( (char *) ((uta_mhdr_t *)msg->header)->src );						// the dest where we're returning the message to
+	hold_ip = strdup( (char *) ((uta_mhdr_t *)msg->header)->srcip );					// both the src host and src ip
 	strncpy( (char *) ((uta_mhdr_t *)msg->header)->src, ctx->my_name, RMR_MAX_SRC );	// must overlay the source to be ours
 	msg = send_msg( ctx, msg, nn_sock, -1 );
 	if( msg ) {
 		strncpy( (char *) ((uta_mhdr_t *)msg->header)->src, hold_src, RMR_MAX_SRC );	// always return original source so rts can be called again
+		strncpy( (char *) ((uta_mhdr_t *)msg->header)->srcip, hold_ip, RMR_MAX_SRC );	// always return original source so rts can be called again
 		msg->flags |= MFL_ADDSRC;														// if msg given to send() it must add source
 	}
 
 	free( hold_src );
+	free( hold_ip );
 	return msg;
 }
 
@@ -345,6 +352,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 +373,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 +411,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 +467,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 +491,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 +536,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 +569,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" );
@@ -583,6 +595,7 @@ static void* init(  char* uproto_port, int max_msg_size, int flags ) {
 	char*	proto_port;
 	char	wbuf[1024];					// work buffer
 	char*	tok;						// pointer at token in a buffer
+	char*	tok2;
 	int		state;
 
 	if( ! announced ) {
@@ -639,13 +652,29 @@ static void* init(  char* uproto_port, int max_msg_size, int flags ) {
 		port = proto_port;			// assume something like "1234" was passed
 	}
 
-	if( (gethostname( wbuf, sizeof( wbuf ) )) != 0 ) {
-		fprintf( stderr, "[CRI] rmr_init: cannot determine localhost name: %s\n", strerror( errno ) );
-		return NULL;
-	}
-	if( (tok = strchr( wbuf, '.' )) != NULL ) {
-		*tok = 0;									// we don't keep domain portion
+	if( (tok = getenv( ENV_SRC_ID )) != NULL ) {							// env var overrides what we dig from system
+		tok = strdup( tok );					// something we can destroy
+		if( *tok == '[' ) {						// we allow an ipv6 address here
+			tok2 = strchr( tok, ']' ) + 1;		// we will chop the port (...]:port) if given
+		} else {
+			tok2 = strchr( tok, ':' );			// find :port if there so we can chop
+		}
+		if( tok2  && *tok2 ) {					// if it's not the end of string marker
+			*tok2 = 0;							// make it so
+		}
+
+		snprintf( wbuf, RMR_MAX_SRC, "%s", tok );
+		free( tok );
+	} else {
+		if( (gethostname( wbuf, sizeof( wbuf ) )) != 0 ) {
+			fprintf( stderr, "[CRI] rmr_init: cannot determine localhost name: %s\n", strerror( errno ) );
+			return NULL;
+		}
+		if( (tok = strchr( wbuf, '.' )) != NULL ) {
+			*tok = 0;									// we don't keep domain portion
+		}
 	}
+
 	ctx->my_name = (char *) malloc( sizeof( char ) * RMR_MAX_SRC );
 	if( snprintf( ctx->my_name, RMR_MAX_SRC, "%s:%s", wbuf, port ) >= RMR_MAX_SRC ) {			// our registered name is host:port
 		fprintf( stderr, "[CRI] rmr_init: hostname + port must be less than %d characters; %s:%s is not\n", RMR_MAX_SRC, wbuf, port );
@@ -664,12 +693,17 @@ static void* init(  char* uproto_port, int max_msg_size, int flags ) {
 	} else {
 		ctx->my_ip = get_default_ip( ctx->ip_list );	// and (guess) at what should be the default to put into messages as src
 		if( ctx->my_ip == NULL ) {
-			fprintf( stderr, "[WARN] rmr_init: default ip address could not be sussed out, using name\n" );
+			fprintf( stderr, "[WRN] rmr_init: default ip address could not be sussed out, using name\n" );
 			strcpy( ctx->my_ip, ctx->my_name );			// if we cannot suss it out, use the name rather than a nil pointer
 		}
 	}
 	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 ) {
@@ -679,7 +713,7 @@ static void* init(  char* uproto_port, int max_msg_size, int flags ) {
 	//       rather than using this generic listen() call.
 	snprintf( bind_info, sizeof( bind_info ), "%s://%s:%s", proto, interface, port );
 	if( (state = nng_listen( ctx->nn_sock, bind_info, NULL, NO_FLAGS )) != 0 ) {
-		fprintf( stderr, "[CRIT] rmr_init: unable to start nng listener for %s: %s\n", bind_info, nng_strerror( state ) );
+		fprintf( stderr, "[CRI] rmr_init: unable to start nng listener for %s: %s\n", bind_info, nng_strerror( state ) );
 		nng_close( ctx->nn_sock );
 		free_ctx( ctx );
 		return NULL;
@@ -687,14 +721,14 @@ static void* init(  char* uproto_port, int max_msg_size, int flags ) {
 
 	if( !(flags & FL_NOTHREAD) ) {										// skip if internal function that doesnt need an rtc
 		if( pthread_create( &ctx->rtc_th,  NULL, rtc, (void *) ctx ) ) { 	// kick the rt collector thread
-			fprintf( stderr, "[WARN] rmr_init: unable to start route table collector thread: %s", strerror( errno ) );
+			fprintf( stderr, "[WRN] rmr_init: unable to start route table collector thread: %s", strerror( errno ) );
 		}
 	}
 
 	if( (flags & RMRFL_MTCALL) && ! (ctx->flags & CFL_MTC_ENABLED) ) {	// mt call support is on, must start the listener thread if not running
 		ctx->flags |= CFL_MTC_ENABLED;
 		if( pthread_create( &ctx->mtc_th,  NULL, mt_receive, (void *) ctx ) ) { 	// kick the receiver
-			fprintf( stderr, "[WARN] rmr_init: unable to start multi-threaded receiver: %s", strerror( errno ) );
+			fprintf( stderr, "[WRN] rmr_init: unable to start multi-threaded receiver: %s", strerror( errno ) );
 		}
 		
 	}
@@ -827,6 +861,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 +870,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;
 	}
@@ -846,7 +882,7 @@ extern rmr_mbuf_t* rmr_mt_rcv( void* vctx, rmr_mbuf_t* mbuf, int max_wait ) {
 	}
 
 	chute = &ctx->chutes[0];					// chute 0 used only for its semaphore
-	
+
 	if( max_wait > 0 ) {
 		clock_gettime( CLOCK_REALTIME, &ts );	
 
@@ -867,36 +903,36 @@ extern rmr_mbuf_t* rmr_mt_rcv( void* vctx, rmr_mbuf_t* mbuf, int max_wait ) {
 		seconds = 1;													// use as flag later to invoked timed wait
 	}
 
-	errno = 0;
-	while( chute->mbuf == NULL && ! errno ) {
+	errno = EINTR;
+	state = -1;
+	while( state < 0 && errno == EINTR ) {
 		if( seconds ) {
 			state = sem_timedwait( &chute->barrier, &ts );				// wait for msg or timeout
 		} else {
 			state = sem_wait( &chute->barrier );
 		}
-
-		if( state < 0 && errno == EINTR ) {								// interrupted go back and wait; all other errors cause exit
-			errno = 0;
-		}
 	}
 
 	if( state < 0 ) {
 		mbuf = ombuf;				// return caller's buffer if they passed one in
 	} else {
+		errno = 0;						// interrupted call state could be left; clear
 		if( DEBUG ) fprintf( stderr, "[DBUG] mt_rcv extracting from normal ring\n" );
 		if( (mbuf = (rmr_mbuf_t *) uta_ring_extract( ctx->mring )) != NULL ) {			// pop if queued
-			if( mbuf ) {
-				mbuf->state = RMR_OK;
-
-				if( ombuf ) {
-					rmr_free_msg( ombuf );					// we cannot reuse as mbufs are queued on the ring
-				}
-			} else {
-				mbuf = ombuf;				// no buffer, return user's if there
+			mbuf->state = RMR_OK;
+
+			if( ombuf ) {
+				rmr_free_msg( ombuf );					// we cannot reuse as mbufs are queued on the ring
 			}
+		} else {
+			errno = ETIMEDOUT;
+			mbuf = ombuf;				// no buffer, return user's if there
 		}
 	}
 
+	if( mbuf ) {
+		mbuf->tp_state = errno;
+	}
 	return mbuf;
 }
 
@@ -928,9 +964,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 +975,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 +1023,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 ) {