/// <summary>Send back an ONC/RPC reply to the original caller.</summary>
/// <remarks>
/// Send back an ONC/RPC reply to the original caller. This is rather a
/// low-level method, typically not used by applications. Dispatcher handling
/// ONC/RPC calls have to use the
/// <see cref="OncRpcCallInformation.reply(org.acplt.oncrpc.XdrAble)">OncRpcCallInformation.reply(org.acplt.oncrpc.XdrAble)
/// </see>
/// method instead on the
/// call object supplied to the handler.
/// </remarks>
/// <param name="callInfo">
/// information about the original call, which are necessary
/// to send back the reply to the appropriate caller.
/// </param>
/// <param name="state">
/// ONC/RPC reply message header indicating success or failure
/// and containing associated state information.
/// </param>
/// <param name="reply">
/// If not <code>null</code>, then this parameter references
/// the reply to be serialized after the reply message header.
/// </param>
/// <exception cref="org.acplt.oncrpc.OncRpcException">
/// if an ONC/RPC exception occurs, like the data
/// could not be successfully serialized.
/// </exception>
/// <exception cref="System.IO.IOException">
/// if an I/O exception occurs, like transmission
/// failures over the network, etc.
/// </exception>
/// <seealso cref="OncRpcCallInformation">OncRpcCallInformation</seealso>
/// <seealso cref="OncRpcDispatchable">OncRpcDispatchable</seealso>
internal override void reply(OncRpcCallInformation callInfo
, OncRpcServerReplyMessage state, XdrAble reply)
{
beginEncoding(callInfo, state);
if (reply != null)
{
reply.xdrEncode(sendingXdr);
}
endEncoding();
}
/// <summary>Calls a remote procedure on an ONC/RPC server.</summary>
/// <remarks>
/// Calls a remote procedure on an ONC/RPC server.
/// <p>The <code>OncRpcUdpClient</code> uses a similar timeout scheme as
/// the genuine Sun C implementation of ONC/RPC: it starts with a timeout
/// of one second when waiting for a reply. If no reply is received within
/// this time frame, the client doubles the timeout, sends a new request
/// and then waits again for a reply. In every case the client will wait
/// no longer than the total timeout set through the
/// <see cref="OncRpcClient.setTimeout(int)">OncRpcClient.setTimeout(int)</see>
/// method.
/// </remarks>
/// <param name="procedureNumber">Procedure number of the procedure to call.</param>
/// <param name="versionNumber">Protocol version number.</param>
/// <param name="params">
/// The parameters of the procedure to call, contained
/// in an object which implements the
/// <see cref="XdrAble">XdrAble</see>
/// interface.
/// </param>
/// <param name="result">The object receiving the result of the procedure call.</param>
/// <exception cref="OncRpcException">if an ONC/RPC error occurs.</exception>
/// <exception cref="org.acplt.oncrpc.OncRpcException"></exception>
public override void call(int procedureNumber, int versionNumber, XdrAble
@params, XdrAble result)
{
lock (this)
{
//Refresh:
for (int refreshesLeft = 1; refreshesLeft >= 0; --refreshesLeft)
{
bool refreshFlag = false;
//
// First, build the ONC/RPC call header. Then put the sending
// stream into a known state and encode the parameters to be
// sent. Finally tell the encoding stream to send all its data
// to the server. Then wait for an answer, receive it and decode
// it. So that's the bottom line of what we do right here.
//
nextXid();
//
// We only create our request message once and reuse it in case
// retransmission should be necessary -- with the exception being
// credential refresh. In this case we need to create a new
// request message.
//
OncRpcClientCallMessage callHeader = new OncRpcClientCallMessage
(xid, program, versionNumber, procedureNumber, auth);
OncRpcClientReplyMessage replyHeader = new OncRpcClientReplyMessage
(auth);
long stopTime = (DateTime.Now.Ticks / TimeSpan.TicksPerMillisecond) + timeout;
int resendTimeout = retransmissionTimeout;
do
{
//
// Now enter the great loop where we send calls out to the server
// and then sit there waiting for a reply. If none comes, we first
// resend our call after one second, then two seconds, four seconds,
// and so on, until we have reached the timeout for the call in total.
// Note that this setting only applies if exponential back-off
// retransmission has been selected. Per default we do not retransmit
// any more, in order to be in line with the SUNRPC implementations.
//
try
{
//
// Send call message to server. Remember that we've already
// "connected" the datagram socket, so java.net knows whom
// to send the datagram packets.
//
sendingXdr.beginEncoding(host, port);
callHeader.xdrEncode(sendingXdr);
@params.xdrEncode(sendingXdr);
sendingXdr.endEncoding();
}
catch (System.IO.IOException e)
{
throw (new OncRpcException(OncRpcException.RPC_CANTSEND
, e.Message));
}
//
// Receive reply message from server -- at least try to do so...
// In case of batched calls we don't need no stinkin' answer, so
// we can do other, more interesting things.
//
if (timeout == 0)
{
return;
}
//
// Wait for an answer to arrive...
//
for (; ;)
{
try
{
long currentTimeout = stopTime - (DateTime.Now.Ticks / TimeSpan.TicksPerMillisecond);
if (currentTimeout > resendTimeout)
{
currentTimeout = resendTimeout;
}
else
{
if (currentTimeout < 1)
{
//
// as setSoTimeout interprets a timeout of zero as
// infinite (?§$@%&!!!) we need to ensure that we
// have a finite timeout, albeit maybe an infinitesimal
// finite one.
currentTimeout = 1;
}
}
socket.ReceiveTimeout = (int)currentTimeout;
receivingXdr.beginDecoding();
//
// Only accept incomming reply if it comes from the same
// address we've sent the ONC/RPC call to. Otherwise throw
// away the datagram packet containing the reply and start
// over again, waiting for the next reply to arrive.
//
if (host.Equals(receivingXdr.getSenderAddress()))
{
//
// First, pull off the reply message header of the
// XDR stream. In case we also received a verifier
// from the server and this verifier was invalid, broken
// or tampered with, we will get an
// OncRpcAuthenticationException right here, which will
// propagate up to the caller. If the server reported
// an authentication problem itself, then this will
// be handled as any other rejected ONC/RPC call.
//
try
{
replyHeader.xdrDecode(receivingXdr);
}
catch (org.acplt.oncrpc.OncRpcException e)
{
//
// ** SF bug #1262106 **
//
// We ran into some sort of trouble. Usually this will have
// been a buffer underflow. Whatever, end the decoding process
// and ensure this way that the next call has a chance to start
// from a clean state.
//
receivingXdr.endDecoding();
throw (e);
}
//
// Only deserialize the result, if the reply matches the call
// and if the reply signals a successful call. In case of an
// unsuccessful call (which mathes our call nevertheless) throw
// an exception.
//
if (replyHeader.messageId == callHeader.messageId)
{
if (!replyHeader.successfullyAccepted())
{
receivingXdr.endDecoding();
//
// Check whether there was an authentication
// problem. In this case first try to refresh the
// credentials.
//
if ((refreshesLeft > 0) && (replyHeader.replyStatus == org.acplt.oncrpc.OncRpcReplyStatus
.ONCRPC_MSG_DENIED) && (replyHeader.rejectStatus == org.acplt.oncrpc.OncRpcRejectStatus
.ONCRPC_AUTH_ERROR) && (auth != null) && auth.canRefreshCred())
{
//
// Think about using a TAB size of four ;)
//
// Another instance of "CONTINUE considered
// useful"...
//
refreshFlag = true;
break;
}
// continue Refresh;
//
// Nope. No chance. This gets tough.
//
throw (replyHeader.newException());
}
//
// The reply header is okay and the call had been
// accepted by the ONC/RPC server, so we can now
// proceed to decode the outcome of the RPC.
//
try
{
result.xdrDecode(receivingXdr);
}
catch (OncRpcException e)
{
//
// ** SF bug #1262106 **
//
// We ran into some sort of trouble. Usually this will have
// been a buffer underflow. Whatever, end the decoding process
// and ensure this way that the next call has a chance to start
// from a clean state.
//
receivingXdr.endDecoding();
throw (e);
}
//
// Free pending resources of buffer and exit the call loop,
// returning the reply to the caller through the result
// object.
//
receivingXdr.endDecoding();
return;
}
}
}
catch (SocketException)
{
//
// The message id did no match -- probably some
// old UDP datagram which just popped up from the
// middle of the Internet.
//
// Yet another case of "CONTINUE considered not
// harmful"...
//
// [Nothing to do here, just wait for the next datagram]
//
// IP address of received UDP datagram is not the same
// as the IP address of the ONC/RPC server.
//
// [Nothing to do here, just wait for the next datagram]
//
// Note that we only catch timeouts here, but no other
// exceptions. Those others will go up further until someone
// catches them. The timeouts are caught, so they can do no
// damage but instead we start another round of sending a
// request and waiting for a reply. Reminds me of NASA and
// their "Mars Polar Lander"...
//
// Note that we need to leave the inner waiting loop here,
// as we might need to resend the (lost) RPC request
// datagram.
//
//Console.Out.WriteLine("This is supposed to be ignored");
//Console.Out.WriteLine(e.Message);
//Console.Out.WriteLine(e.StackTrace);
break;
}
catch (IOException e)
{
//
// Argh. Trouble with the transport. Seems like we can't
// receive data. Gosh. Go away!
//
try
{
receivingXdr.endDecoding();
}
catch (IOException)
{
}
// skip UDP record
throw (new OncRpcException(OncRpcException.RPC_CANTRECV
, e.Message));
}
catch (org.acplt.oncrpc.OncRpcException e)
{
//
// Ooops. An ONC/RPC exception. Let us rethrow this one,
// as we won't have nothin' to do with it...
//
try
{
receivingXdr.endDecoding();
}
catch (System.IO.IOException)
{
}
// skip UDP record
//
// Well, in case we got not a *reply* RPC message back,
// we keep listening for messages.
//
if (e.getReason() != org.acplt.oncrpc.OncRpcException.RPC_WRONGMESSAGE)
{
throw (e);
}
}
//
// We can not make use of the reply we just received, so
// we need to dump it.
//
// This should raise no exceptions, when skipping the UDP
// record. So if one is raised, we will rethrow an ONC/RPC
// exception instead.
//
try
{
receivingXdr.endDecoding();
}
catch (System.IO.IOException e)
{
throw (new OncRpcException(OncRpcException.RPC_CANTRECV
, e.Message));
}
}
// jmw 12/18/2009 fix for refresh/continue in Java code
if (refreshFlag)
{
break;
}
//
// We only reach this code part beyond the inner waiting
// loop if we run in a timeout and might need to retransmit
//
// According to the retransmission strategy choosen, update the
// current retransmission (resending) timeout.
//
if (retransmissionMode == org.acplt.oncrpc.OncRpcUdpRetransmissionMode.EXPONENTIAL)
{
resendTimeout *= 2;
}
}while (DateTime.Now.Ticks / TimeSpan.TicksPerMillisecond < stopTime);
// jmw 12/18/2009 don't want to throw an exception here
if (refreshFlag)
{
continue;
}
//
// That's it -- this shitty server does not talk to us. Now, due to
// the indecent language used in the previous sentence, this software
// can not be exported any longer to some countries of the world.
// But this is surely not my problem, but rather theirs. So go away
// and hide yourself in the dark with all your zombies (or maybe
// kangaroos).
//
throw (new OncRpcTimeoutException());
}
}
}
/// <summary>Calls a remote procedure on an ONC/RPC server.</summary>
/// <remarks>
/// Calls a remote procedure on an ONC/RPC server.
/// <p>The <code>OncRpcUdpClient</code> uses a similar timeout scheme as
/// the genuine Sun C implementation of ONC/RPC: it starts with a timeout
/// of one second when waiting for a reply. If no reply is received within
/// this time frame, the client doubles the timeout, sends a new request
/// and then waits again for a reply. In every case the client will wait
/// no longer than the total timeout set through the
/// <see cref="OncRpcClient.setTimeout(int)">OncRpcClient.setTimeout(int)</see>
/// method.
/// </remarks>
/// <param name="procedureNumber">Procedure number of the procedure to call.</param>
/// <param name="versionNumber">Protocol version number.</param>
/// <param name="params">
/// The parameters of the procedure to call, contained
/// in an object which implements the
/// <see cref="XdrAble">XdrAble</see>
/// interface.
/// </param>
/// <param name="result">The object receiving the result of the procedure call.</param>
/// <exception cref="OncRpcException">if an ONC/RPC error occurs.</exception>
/// <exception cref="org.acplt.oncrpc.OncRpcException"></exception>
public override void call(int procedureNumber, int versionNumber, XdrAble
@params, XdrAble result)
{
lock (this)
{
//Refresh:
for (int refreshesLeft = 1; refreshesLeft >= 0; --refreshesLeft)
{
bool refreshFlag = false;
//
// First, build the ONC/RPC call header. Then put the sending
// stream into a known state and encode the parameters to be
// sent. Finally tell the encoding stream to send all its data
// to the server. Then wait for an answer, receive it and decode
// it. So that's the bottom line of what we do right here.
//
nextXid();
//
// We only create our request message once and reuse it in case
// retransmission should be necessary -- with the exception being
// credential refresh. In this case we need to create a new
// request message.
//
OncRpcClientCallMessage callHeader = new OncRpcClientCallMessage
(xid, program, versionNumber, procedureNumber, auth);
OncRpcClientReplyMessage replyHeader = new OncRpcClientReplyMessage
(auth);
long stopTime = (DateTime.Now.Ticks/TimeSpan.TicksPerMillisecond) + timeout;
int resendTimeout = retransmissionTimeout;
do
{
//
// Now enter the great loop where we send calls out to the server
// and then sit there waiting for a reply. If none comes, we first
// resend our call after one second, then two seconds, four seconds,
// and so on, until we have reached the timeout for the call in total.
// Note that this setting only applies if exponential back-off
// retransmission has been selected. Per default we do not retransmit
// any more, in order to be in line with the SUNRPC implementations.
//
try
{
//
// Send call message to server. Remember that we've already
// "connected" the datagram socket, so java.net knows whom
// to send the datagram packets.
//
sendingXdr.beginEncoding(host, port);
callHeader.xdrEncode(sendingXdr);
@params.xdrEncode(sendingXdr);
sendingXdr.endEncoding();
}
catch (System.IO.IOException e)
{
throw (new OncRpcException(OncRpcException.RPC_CANTSEND
, e.Message));
}
//
// Receive reply message from server -- at least try to do so...
// In case of batched calls we don't need no stinkin' answer, so
// we can do other, more interesting things.
//
if (timeout == 0)
{
return;
}
//
// Wait for an answer to arrive...
//
for (; ; )
{
try
{
long currentTimeout = stopTime - (DateTime.Now.Ticks/TimeSpan.TicksPerMillisecond);
if (currentTimeout > resendTimeout)
{
currentTimeout = resendTimeout;
}
else
{
if (currentTimeout < 1)
{
//
// as setSoTimeout interprets a timeout of zero as
// infinite (?§$@%&!!!) we need to ensure that we
// have a finite timeout, albeit maybe an infinitesimal
// finite one.
currentTimeout = 1;
}
}
socket.ReceiveTimeout = (int) currentTimeout;
receivingXdr.beginDecoding();
//
// Only accept incomming reply if it comes from the same
// address we've sent the ONC/RPC call to. Otherwise throw
// away the datagram packet containing the reply and start
// over again, waiting for the next reply to arrive.
//
if (host.Equals(receivingXdr.getSenderAddress()))
{
//
// First, pull off the reply message header of the
// XDR stream. In case we also received a verifier
// from the server and this verifier was invalid, broken
// or tampered with, we will get an
// OncRpcAuthenticationException right here, which will
// propagate up to the caller. If the server reported
// an authentication problem itself, then this will
// be handled as any other rejected ONC/RPC call.
//
try
{
replyHeader.xdrDecode(receivingXdr);
}
catch (org.acplt.oncrpc.OncRpcException e)
{
//
// ** SF bug #1262106 **
//
// We ran into some sort of trouble. Usually this will have
// been a buffer underflow. Whatever, end the decoding process
// and ensure this way that the next call has a chance to start
// from a clean state.
//
receivingXdr.endDecoding();
throw (e);
}
//
// Only deserialize the result, if the reply matches the call
// and if the reply signals a successful call. In case of an
// unsuccessful call (which mathes our call nevertheless) throw
// an exception.
//
if (replyHeader.messageId == callHeader.messageId)
{
if (!replyHeader.successfullyAccepted())
{
receivingXdr.endDecoding();
//
// Check whether there was an authentication
// problem. In this case first try to refresh the
// credentials.
//
if ((refreshesLeft > 0) && (replyHeader.replyStatus == org.acplt.oncrpc.OncRpcReplyStatus
.ONCRPC_MSG_DENIED) && (replyHeader.rejectStatus == org.acplt.oncrpc.OncRpcRejectStatus
.ONCRPC_AUTH_ERROR) && (auth != null) && auth.canRefreshCred())
{
//
// Think about using a TAB size of four ;)
//
// Another instance of "CONTINUE considered
// useful"...
//
refreshFlag = true;
break;
}
// continue Refresh;
//
// Nope. No chance. This gets tough.
//
throw (replyHeader.newException());
}
//
// The reply header is okay and the call had been
// accepted by the ONC/RPC server, so we can now
// proceed to decode the outcome of the RPC.
//
try
{
result.xdrDecode(receivingXdr);
}
catch (OncRpcException e)
{
//
// ** SF bug #1262106 **
//
// We ran into some sort of trouble. Usually this will have
// been a buffer underflow. Whatever, end the decoding process
// and ensure this way that the next call has a chance to start
// from a clean state.
//
receivingXdr.endDecoding();
throw (e);
}
//
// Free pending resources of buffer and exit the call loop,
// returning the reply to the caller through the result
// object.
//
receivingXdr.endDecoding();
return;
}
}
}
catch (SocketException)
{
//
// The message id did no match -- probably some
// old UDP datagram which just popped up from the
// middle of the Internet.
//
// Yet another case of "CONTINUE considered not
// harmful"...
//
// [Nothing to do here, just wait for the next datagram]
//
// IP address of received UDP datagram is not the same
// as the IP address of the ONC/RPC server.
//
// [Nothing to do here, just wait for the next datagram]
//
// Note that we only catch timeouts here, but no other
// exceptions. Those others will go up further until someone
// catches them. The timeouts are caught, so they can do no
// damage but instead we start another round of sending a
// request and waiting for a reply. Reminds me of NASA and
// their "Mars Polar Lander"...
//
// Note that we need to leave the inner waiting loop here,
// as we might need to resend the (lost) RPC request
// datagram.
//
//Console.Out.WriteLine("This is supposed to be ignored");
//Console.Out.WriteLine(e.Message);
//Console.Out.WriteLine(e.StackTrace);
break;
}
catch (IOException e)
{
//
// Argh. Trouble with the transport. Seems like we can't
// receive data. Gosh. Go away!
//
try
{
receivingXdr.endDecoding();
}
catch (IOException)
{
}
// skip UDP record
throw (new OncRpcException(OncRpcException.RPC_CANTRECV
, e.Message));
}
catch (org.acplt.oncrpc.OncRpcException e)
{
//
// Ooops. An ONC/RPC exception. Let us rethrow this one,
// as we won't have nothin' to do with it...
//
try
{
receivingXdr.endDecoding();
}
catch (System.IO.IOException)
{
}
// skip UDP record
//
// Well, in case we got not a *reply* RPC message back,
// we keep listening for messages.
//
if (e.getReason() != org.acplt.oncrpc.OncRpcException.RPC_WRONGMESSAGE)
{
throw (e);
}
}
//
// We can not make use of the reply we just received, so
// we need to dump it.
//
// This should raise no exceptions, when skipping the UDP
// record. So if one is raised, we will rethrow an ONC/RPC
// exception instead.
//
try
{
receivingXdr.endDecoding();
}
catch (System.IO.IOException e)
{
throw (new OncRpcException(OncRpcException.RPC_CANTRECV
, e.Message));
}
}
// jmw 12/18/2009 fix for refresh/continue in Java code
if (refreshFlag)
{
break;
}
//
// We only reach this code part beyond the inner waiting
// loop if we run in a timeout and might need to retransmit
//
// According to the retransmission strategy choosen, update the
// current retransmission (resending) timeout.
//
if (retransmissionMode == org.acplt.oncrpc.OncRpcUdpRetransmissionMode.EXPONENTIAL)
{
resendTimeout *= 2;
}
}
while (DateTime.Now.Ticks/TimeSpan.TicksPerMillisecond < stopTime);
// jmw 12/18/2009 don't want to throw an exception here
if (refreshFlag)
{
continue;
}
//
// That's it -- this shitty server does not talk to us. Now, due to
// the indecent language used in the previous sentence, this software
// can not be exported any longer to some countries of the world.
// But this is surely not my problem, but rather theirs. So go away
// and hide yourself in the dark with all your zombies (or maybe
// kangaroos).
//
throw (new OncRpcTimeoutException());
}
}
}
/// <summary>Send back an ONC/RPC reply to the original caller.</summary>
/// <remarks>
/// Send back an ONC/RPC reply to the original caller. This is rather a
/// low-level method, typically not used by applications. Dispatcher handling
/// ONC/RPC calls have to use the
/// <see cref="OncRpcCallInformation.reply(org.acplt.oncrpc.XdrAble)">OncRpcCallInformation.reply(org.acplt.oncrpc.XdrAble)
/// </see>
/// method instead on the
/// call object supplied to the handler.
/// </remarks>
/// <param name="callInfo">
/// information about the original call, which are necessary
/// to send back the reply to the appropriate caller.
/// </param>
/// <param name="state">
/// ONC/RPC reply message header indicating success or failure
/// and containing associated state information.
/// </param>
/// <param name="reply">
/// If not <code>null</code>, then this parameter references
/// the reply to be serialized after the reply message header.
/// </param>
/// <exception cref="org.acplt.oncrpc.OncRpcException">
/// if an ONC/RPC exception occurs, like the data
/// could not be successfully serialized.
/// </exception>
/// <exception cref="System.IO.IOException">
/// if an I/O exception occurs, like transmission
/// failures over the network, etc.
/// </exception>
/// <seealso cref="OncRpcCallInformation">OncRpcCallInformation</seealso>
/// <seealso cref="OncRpcDispatchable">OncRpcDispatchable</seealso>
internal override void reply(OncRpcCallInformation callInfo
, OncRpcServerReplyMessage state, XdrAble reply)
{
beginEncoding(callInfo, state);
if (reply != null)
{
reply.xdrEncode(sendingXdr);
}
endEncoding();
}