X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;f=src%2Frmr%2Fsi%2Fsrc%2Frmr_si.c;h=8606241179cf011fe4843fab07a7d8ac791dbf8f;hb=8633a0b93e26b619a367de0614437ef2eb4a0b37;hp=047401d5f6862139d636e2d0a4de5277b609f3d0;hpb=3c832c14cdda950ebd2efea2f53e4ed99de81521;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 047401d..8606241 100644
--- a/src/rmr/si/src/rmr_si.c
+++ b/src/rmr/si/src/rmr_si.c
@@ -204,7 +204,7 @@ extern rmr_mbuf_t* rmr_mtosend_msg( void* vctx, rmr_mbuf_t* msg, int max_to ) {
 		((uta_mhdr_t *) msg->header)->flags &= ~HFL_CALL_MSG;			// must ensure call flag is off
 
 		d1 = DATA1_ADDR( msg->header );
-		d1[D1_CALLID_IDX] = NO_CALL_ID;										// must blot out so it doesn't queue on a chute at the other end
+		d1[D1_CALLID_IDX] = NO_CALL_ID;									// must blot out so it doesn't queue on a chute at the other end
 	}
 
 	return mtosend_msg( vctx, msg, max_to );
@@ -939,23 +939,19 @@ 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
 
-	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 the work horse for the multi-threaded call() function. It supports
+	both the rmr_mt_call() and the rmr_wormhole wh_call() functions. See the description
+	for for rmr_mt_call() modulo the caveat below.
+
+	If endpoint is given, then we assume that we're not doing normal route table
+	routing and that we should send directly to that endpoint (probably worm
+	hole).
 */
-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
@@ -1023,7 +1019,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 ) {										// normal routing
+		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;
@@ -1066,6 +1066,29 @@ extern rmr_mbuf_t* rmr_mt_call( void* vctx, rmr_mbuf_t* mbuf, int call_id, int m
 	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 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 ) {
+	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