X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;f=src%2Frmr%2Fnng%2Fsrc%2Frmr_nng.c;h=8d55b441100bfa21f735e3fcbae660f334709dda;hb=338fe5e46223df8145b53cdf52dab358f18c7f26;hp=faae3331037647e2c51b481965cc41af7f8d5139;hpb=4919b11a06c3c96652121922c010c31f27471756;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 faae333..8d55b44 100644
--- a/src/rmr/nng/src/rmr_nng.c
+++ b/src/rmr/nng/src/rmr_nng.c
@@ -700,6 +700,7 @@ static void* init(  char* uproto_port, int max_msg_size, int flags ) {
 	} else {
 		if( (gethostname( wbuf, sizeof( wbuf ) )) != 0 ) {
 			rmr_vlog( RMR_VL_CRIT, "rmr_init: cannot determine localhost name: %s\n", strerror( errno ) );
+			free( proto_port );
 			return NULL;
 		}
 		if( (tok = strchr( wbuf, '.' )) != NULL ) {
@@ -726,7 +727,7 @@ static void* init(  char* uproto_port, int max_msg_size, int flags ) {
 		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 ) {
 			rmr_vlog( RMR_VL_WARN, "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
+			ctx->my_ip = strdup( ctx->my_name );		// if we cannot suss it out, use the name rather than a nil pointer
 		}
 	}
 	if( DEBUG ) rmr_vlog( RMR_VL_DEBUG, "default ip address: %s\n", ctx->my_ip );
@@ -747,6 +748,7 @@ static void* init(  char* uproto_port, int max_msg_size, int flags ) {
 	if( (state = nng_listen( ctx->nn_sock, bind_info, NULL, NO_FLAGS )) != 0 ) {
 		rmr_vlog( RMR_VL_CRIT, "rmr_init: unable to start nng listener for %s: %s\n", bind_info, nng_strerror( state ) );
 		nng_close( ctx->nn_sock );
+		free( proto_port );
 		free_ctx( ctx );
 		return NULL;
 	}
@@ -976,23 +978,15 @@ extern rmr_mbuf_t* rmr_mt_rcv( void* vctx, rmr_mbuf_t* mbuf, int max_wait ) {
 	return mbuf;
 }
 
-/*
-	Accept a message buffer and caller ID, send the message and then wait
-	for the receiver to tickle the semaphore letting us know that a message
-	has been received. The call_id is a value between 2 and 255, inclusive; if
-	it's not in this range an error will be returned. Max wait is the amount
-	of time in millaseconds that the call should block for. If 0 is given
-	then no timeout is set.
 
-	If the mt_call feature has not been initialised, then the attempt to use this
-	funciton will fail with RMR_ERR_NOTSUPP
+/*
+	This does the real work behind both of the outward facing call functions. See 
+	the rmr_mt_call() description for details modulo the comments blow.
 
-	If no matching message is received before the max_wait period expires, a
-	nil pointer is returned, and errno is set to ETIMEOUT. If any other error
-	occurs after the message has been sent, then a nil pointer is returned
-	with errno set to some other value.
+	If ep is given, then we skip the normal route table endpoint selection. This is
+	likely a wormhole call.
 */
-extern rmr_mbuf_t* rmr_mt_call( void* vctx, rmr_mbuf_t* mbuf, int call_id, int max_wait ) {
+static rmr_mbuf_t* mt_call( void* vctx, rmr_mbuf_t* mbuf, int call_id, int max_wait, endpoint_t* ep ) {
 	rmr_mbuf_t* ombuf;			// original mbuf passed in
 	uta_ctx_t*	ctx;
 	uta_mhdr_t*	hdr;			// header in the transport buffer
@@ -1060,7 +1054,11 @@ extern rmr_mbuf_t* rmr_mt_call( void* vctx, rmr_mbuf_t* mbuf, int call_id, int m
 		seconds = 1;										// use as flag later to invoked timed wait
 	}
 
-	mbuf = mtosend_msg( ctx, mbuf, 0 );						// use internal function so as not to strip call-id; should be nil on success!
+	if( ep != NULL ) {
+		mbuf = mtosend_msg( ctx, mbuf, 0 );					// use internal function so as not to strip call-id; should be nil on success!
+	} else {
+		mbuf = send_msg( ctx, mbuf, ep->nn_sock, -1 );
+	}
 	if( mbuf ) {
 		if( mbuf->state != RMR_OK ) {
 			mbuf->tp_state = errno;
@@ -1068,7 +1066,7 @@ extern rmr_mbuf_t* rmr_mt_call( void* vctx, rmr_mbuf_t* mbuf, int call_id, int m
 		}
 	}
 
-	state = 0;
+	state = -1;												
 	errno = 0;
 	while( chute->mbuf == NULL && ! errno ) {
 		if( seconds ) {
@@ -1094,13 +1092,38 @@ extern rmr_mbuf_t* rmr_mt_call( void* vctx, rmr_mbuf_t* mbuf, int call_id, int m
 		return NULL;					// leave errno as set by sem wait call
 	}
 
-	mbuf = chute->mbuf;
-	mbuf->state = RMR_OK;
+	if( (mbuf = chute->mbuf) != NULL ) {
+		mbuf->state = RMR_OK;
+	}
 	chute->mbuf = NULL;
 
 	return mbuf;
 }
 
+/*
+	Accept a message buffer and caller ID, send the message and then wait
+	for the receiver to tickle the semaphore letting us know that a message
+	has been received. The call_id is a value between 2 and 255, inclusive; if
+	it's not in this range an error will be returned. Max wait is the amount
+	of time in millaseconds that the call should block for. If 0 is given
+	then no timeout is set.
+
+	If the mt_call feature has not been initialised, then the attempt to use this
+	funciton will fail with RMR_ERR_NOTSUPP
+
+	If no matching message is received before the max_wait period expires, a
+	nil pointer is returned, and errno is set to ETIMEOUT. If any other error
+	occurs after the message has been sent, then a nil pointer is returned
+	with errno set to some other value.
+
+	This is now just a wrapper to the real work horse so that we can provide
+	this and wormhole call functions without duplicating code.
+
+*/
+extern rmr_mbuf_t* rmr_mt_call( void* vctx, rmr_mbuf_t* mbuf, int call_id, int max_wait ) {
+	return mt_call( vctx, mbuf, call_id, max_wait, NULL );
+}
+
 /*
 	Given an existing message buffer, reallocate the payload portion to
 	be at least new_len bytes.  The message header will remain such that