X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;f=src%2Frmr%2Fsi%2Fsrc%2Frmr_si.c;h=4aefe4a55c1cfda1b610a196c29d4cca8245c6f6;hb=0b4dcf0947ba33b2a5d4e870f210c2bc93330c1d;hp=78a90ff8d05e9c92ce04a7b54bf2d1e4c3cbdf21;hpb=c113b0836f3ebd58911c30de1636a707174efe55;p=ric-plt%2Flib%2Frmr.git

diff --git a/src/rmr/si/src/rmr_si.c b/src/rmr/si/src/rmr_si.c
index 78a90ff..4aefe4a 100644
--- a/src/rmr/si/src/rmr_si.c
+++ b/src/rmr/si/src/rmr_si.c
@@ -370,7 +370,7 @@ extern rmr_mbuf_t* rmr_call( void* vctx, rmr_mbuf_t* msg ) {
 		return msg;
 	}
 
-	return rmr_mt_call( vctx, msg, 1, 1000 );		// use the reserved call-id of 1 and wait up to 1 sec
+    return mt_call( vctx, msg, 1, 1000, NULL );		// use the reserved call-id of 1 and wait up to 1 sec
 }
 
 /*
@@ -532,7 +532,7 @@ extern int rmr_set_rtimeout( void* vctx, int time ) {
 				that we know about. The _user_ should ensure that the supplied length also
 				includes the trace data length maximum as they are in control of that.
 */
-static void* init(  char* uproto_port, int max_msg_size, int flags ) {
+static void* init(  char* uproto_port, int def_msg_size, int flags ) {
 	static	int announced = 0;
 	uta_ctx_t*	ctx = NULL;
 	char	bind_info[256];				// bind info
@@ -581,7 +581,7 @@ static void* init(  char* uproto_port, int max_msg_size, int flags ) {
 
 	ctx->send_retries = 1;							// default is not to sleep at all; RMr will retry about 10K times before returning
 	ctx->d1_len = 4;								// data1 space in header -- 4 bytes for now
-	ctx->max_ibm = max_msg_size < 1024 ? 1024 : max_msg_size;					// larger than their request doesn't hurt
+	ctx->max_ibm = def_msg_size < 1024 ? 1024 : def_msg_size;					// larger than their request doesn't hurt
 	ctx->max_ibm += sizeof( uta_mhdr_t ) + ctx->d1_len + ctx->d2_len + TP_HDR_LEN + 64;		// add in header size, transport hdr, and a bit of fudge
 
 	ctx->mring = uta_mk_ring( 4096 );				// message ring is always on for si
@@ -598,8 +598,8 @@ static void* init(  char* uproto_port, int max_msg_size, int flags ) {
 
 
 	ctx->max_plen = RMR_MAX_RCV_BYTES;				// max user payload lengh
-	if( max_msg_size > 0 ) {
-		ctx->max_plen = max_msg_size;
+	if( def_msg_size > 0 ) {
+		ctx->max_plen = def_msg_size;
 	}
 
 	// we're using a listener to get rtg updates, so we do NOT need this.
@@ -623,7 +623,7 @@ static void* init(  char* uproto_port, int max_msg_size, int flags ) {
 		port = proto_port;			// assume something like "1234" was passed
 	}
 
-	if( (tok = getenv( "ENV_RTG_PORT" )) != NULL && atoi( tok ) < 1 ) { 	// must check here -- if < 1 then we just start static file 'listener'
+	if( (tok = getenv( ENV_RTG_PORT )) != NULL && atoi( tok ) < 1 ) { 	// must check here -- if < 1 then we just start static file 'listener'
 		static_rtc = 1;
 	}
 
@@ -699,10 +699,12 @@ static void* init(  char* uproto_port, int max_msg_size, int flags ) {
 		ctx->rtable = rt_clone_space( NULL, NULL, 0 );		// creates an empty route table so that wormholes still can be used
 	} else {
 		if( static_rtc ) {
+			rmr_vlog( RMR_VL_INFO, "rmr_init: file based route table only for context on port %s\n", uproto_port );
 			if( pthread_create( &ctx->rtc_th,  NULL, rtc_file, (void *) ctx ) ) { 	// kick the rt collector thread as just file reader
 				rmr_vlog( RMR_VL_WARN, "rmr_init: unable to start static route table collector thread: %s", strerror( errno ) );
 			}
 		} else {
+			rmr_vlog( RMR_VL_INFO, "rmr_init: dynamic route table for context on port %s\n", uproto_port );
 			if( pthread_create( &ctx->rtc_th,  NULL, rtc, (void *) ctx ) ) { 	// kick the real rt collector thread
 				rmr_vlog( RMR_VL_WARN, "rmr_init: unable to start dynamic route table collector thread: %s", strerror( errno ) );
 			}
@@ -733,8 +735,8 @@ static void* init(  char* uproto_port, int max_msg_size, int flags ) {
 		without drastically changing anything. The user should invoke with RMRFL_NONE to
 		avoid any misbehavour as there are internal flags which are suported
 */
-extern void* rmr_init( char* uproto_port, int max_msg_size, int flags ) {
-	return init( uproto_port, max_msg_size, flags & UFL_MASK  );		// ensure any internal flags are off
+extern void* rmr_init( char* uproto_port, int def_msg_size, int flags ) {
+	return init( uproto_port, def_msg_size, flags & UFL_MASK  );		// ensure any internal flags are off
 }
 
 /*
@@ -872,6 +874,7 @@ extern rmr_mbuf_t* rmr_mt_rcv( void* vctx, rmr_mbuf_t* mbuf, int max_wait ) {
 		if( mbuf != NULL ) {
 			mbuf->flags |= MFL_ADDSRC;               // turn on so if user app tries to send this buffer we reset src
 		}
+
 		return mbuf;
 	}
 
@@ -972,12 +975,6 @@ static rmr_mbuf_t* mt_call( void* vctx, rmr_mbuf_t* mbuf, int call_id, int max_w
 		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;
-	}
-
 	ombuf = mbuf;													// save to return timeout status with
 
 	chute = &ctx->chutes[call_id];
@@ -1079,6 +1076,14 @@ static rmr_mbuf_t* mt_call( void* vctx, rmr_mbuf_t* mbuf, int call_id, int max_w
 	This is now just an outward facing wrapper so we can support wormhole calls.
 */
 extern rmr_mbuf_t* rmr_mt_call( void* vctx, rmr_mbuf_t* mbuf, int call_id, int max_wait ) {
+
+	// must vet call_id here, all others vetted by workhorse mt_call() function
+	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 = EINVAL;
+		return mbuf;
+	}
+
 	return mt_call( vctx, mbuf, call_id, max_wait, NULL );
 }